clarifai 11.4.1__py3-none-any.whl → 11.4.3rc1__py3-none-any.whl

clarifai/runners/utils/data_handler.py

@@ -0,0 +1,231 @@
+from typing import Dict, List, Tuple, Union
+
+import numpy as np
+from clarifai_grpc.grpc.api import resources_pb2
+from clarifai_grpc.grpc.api.status import status_code_pb2, status_pb2
+from PIL import Image
+
+from clarifai.client.auth.helper import ClarifaiAuthHelper
+
+from .data_utils import bytes_to_image, image_to_bytes
+
+
+class BaseDataHandler:
+
+  def __init__(self,
+               proto: Union[resources_pb2.Input, resources_pb2.Output],
+               auth: ClarifaiAuthHelper = None):
+    self._proto = proto
+    self._auth = auth
+
+  #
+  def to_python(self):
+    return dict(text=self.text, image=self.image, audio=self.audio)
+
+  # ---------------- Start get/setters ---------------- #
+  # Proto
+  @property
+  def proto(self):
+    return self._proto
+
+  # Status
+  @property
+  def status(self) -> status_pb2.Status:
+    return self._proto.status
+
+  def set_status(self, code: str, description: str = ""):
+    self._proto.status.code = code
+    self._proto.status.description = description
+
+  # Text
+  @property
+  def text(self) -> Union[None, str]:
+    data = self._proto.data.text
+    text = None
+    if data.ByteSize():
+      if data.raw:
+        text = data.raw
+      else:
+        raise NotImplementedError
+    return text
+
+  def set_text(self, text: str):
+    self._proto.data.text.raw = text
+
+  # Image
+  @property
+  def image(self, format: str = "np") -> Union[None, Image.Image, np.ndarray]:
+    data = self._proto.data.image
+    image = None
+    if data.ByteSize():
+      data: resources_pb2.Image = data
+      if data.base64:
+        image = data.base64
+      elif data.url:
+        raise NotImplementedError
+      image = bytes_to_image(image)
+      image = image if not format == "np" else np.asarray(image).astype("uint8")
+    return image
+
+  def set_image(self, image: Union[Image.Image, np.ndarray]):
+    if isinstance(image, np.ndarray):
+      image = Image.fromarray(image)
+    self._proto.data.image.base64 = image_to_bytes(image)
+
+  # Audio
+  @property
+  def audio(self) -> bytes:
+    data = self._proto.data.audio
+    audio = None
+    if data.ByteSize():
+      if data.base64:
+        audio = data.base64
+    return audio
+
+  def set_audio(self, audio: bytes):
+    self._proto.data.audio.base64 = audio
+
+  # Bboxes
+  @property
+  def bboxes(self, real_coord: bool = False, image_width: int = None,
+             image_height: int = None) -> Tuple[List, List, List]:
+    if real_coord:
+      assert (image_height or image_width
+             ), "image_height and image_width are required when when return real coordinates"
+    xyxy = []
+    scores = []
+    concepts = []
+    for _, each in enumerate(self._proto.data.regions):
+      box = each.region_info
+      score = each.value
+      concept = each.data.concepts[0].id
+      x1 = box.left_col
+      y1 = box.top_row
+      x2 = box.right_col
+      y2 = box.bottom_row
+      if real_coord:
+        x1 = x1 * image_width
+        y1 = y1 * image_height
+        x2 = x2 * image_width
+        y2 = y2 * image_height
+      xyxy.append([x1, y1, x2, y2])
+      scores.append(score)
+      concepts.append(concept)
+
+    return xyxy, scores, concepts
+
+  def set_bboxes(self,
+                 boxes: list,
+                 scores: list,
+                 concepts: list,
+                 real_coord: bool = False,
+                 image_width: int = None,
+                 image_height: int = None):
+    if real_coord:
+      assert (image_height and
+              image_width), "image_height and image_width are required when `real_coord` is set"
+      bboxes = [[x[1] / image_height, x[0] / image_width, x[3] / image_height, x[2] / image_width]
+                for x in boxes]  # normalize the bboxes to [0,1] and [y1 x1 y2 x2]
+      bboxes = np.clip(bboxes, 0, 1.0)
+
+    regions = []
+    for ith, bbox in enumerate(bboxes):
+      score = scores[ith]
+      concept = concepts[ith]
+      if any([each > 1.0 for each in bbox]):
+        assert ValueError(
+            "Box coordinates is not normalized between [0, 1]. Please set format_box to True and provide image_height and image_width to normalize"
+        )
+      region = resources_pb2.RegionInfo(bounding_box=resources_pb2.BoundingBox(
+          top_row=bbox[0],  # y_min
+          left_col=bbox[1],  # x_min
+          bottom_row=bbox[2],  # y_max
+          right_col=bbox[3],  # x_max
+      ))
+      data = resources_pb2.Data(concepts=resources_pb2.Concept(id=concept, value=score))
+      regions.append(resources_pb2.Region(region_info=region, data=data))
+
+    self._proto.data.regions = regions
+
+  # Concepts
+  @property
+  def concepts(self) -> Dict[str, float]:
+    con_scores = {}
+    for each in self.proto.data.concepts:
+      con_scores.update({each.id: each.value})
+    return con_scores
+
+  def set_concepts(self, concept_score_pairs: Dict[str, float]):
+    concepts = []
+    for concept, score in concept_score_pairs.items():
+      con_score = resources_pb2.Concept(id=concept, name=concept, value=score)
+      concepts.append(con_score)
+    if concepts:
+      self._proto.data.ClearField("concepts")
+      for each in concepts:
+        self._proto.data.concepts.append(each)
+
+  # Embeddings
+  @property
+  def embeddings(self) -> List[List[float]]:
+    return [each.vector for each in self.proto.data.embeddings]
+
+  def set_embeddings(self, list_vectors: List[List[float]]):
+    if list_vectors[0]:
+      self._proto.data.ClearField("embeddings")
+    for vec in list_vectors:
+      self._proto.data.embeddings.append(
+          resources_pb2.Embedding(vector=vec, num_dimensions=len(vec)))
+
+  # ---------------- End get/setters ---------------- #
+
+  # Constructors
+  @classmethod
+  def from_proto(cls, proto):
+    clss = cls(proto=proto)
+    return clss
+
+  @classmethod
+  def from_data(
+      cls,
+      status_code: int = status_code_pb2.SUCCESS,
+      status_description: str = "",
+      text: str = None,
+      image: Union[Image.Image, np.ndarray] = None,
+      audio: bytes = None,
+      boxes: dict = None,
+      concepts: Dict[str, float] = {},
+      embeddings: List[List[float]] = [],
+  ) -> 'OutputDataHandler':
+    clss = cls(proto=resources_pb2.Output())
+    if isinstance(image, Image.Image) or isinstance(image, np.ndarray):
+      clss.set_image(image)
+    if text:
+      clss.set_text(text)
+    if audio:
+      clss.set_audio(audio)
+    if boxes:
+      clss.set_bboxes(**boxes)
+    if concepts:
+      clss.set_concepts(concepts)
+    if embeddings:
+      clss.set_embeddings(embeddings)
+
+    clss.set_status(code=status_code, description=status_description)
+    return clss
+
+
+class InputDataHandler(BaseDataHandler):
+
+  def __init__(self,
+               proto: resources_pb2.Input = resources_pb2.Input(),
+               auth: ClarifaiAuthHelper = None):
+    super().__init__(proto=proto, auth=auth)
+
+
+class OutputDataHandler(BaseDataHandler):
+
+  def __init__(self,
+               proto: resources_pb2.Output = resources_pb2.Output(),
+               auth: ClarifaiAuthHelper = None):
+    super().__init__(proto=proto, auth=auth)

clarifai/runners/utils/data_utils.py

@@ -1,3 +1,4 @@
+import json
 import math
 import operator
 from io import BytesIO
@@ -64,7 +65,7 @@ class Param(MessageData):
 
     def __init__(
         self,
-        default=None,
+        default,
         description=None,
         min_value=None,
         max_value=None,
@@ -77,6 +78,7 @@ class Param(MessageData):
         self.max_value = max_value
         self.choices = choices
         self.is_param = is_param
+        self._patch_encoder()
 
     def __repr__(self) -> str:
         attrs = []
@@ -153,6 +155,16 @@ class Param(MessageData):
     def __ge__(self, other):
         return self.default >= other
 
+    def __getattribute__(self, name):
+        """Intercept attribute access to mimic default value behavior"""
+        try:
+            # First try to get Param attributes normally
+            return object.__getattribute__(self, name)
+        except AttributeError:
+            # Fall back to the default value's attributes
+            default = object.__getattribute__(self, 'default')
+            return getattr(default, name)
+
     # Arithmetic operators – # arithmetic & bitwise operators – auto-generated
     _arith_ops = {
         "__add__": operator.add,
@@ -169,7 +181,6 @@ class Param(MessageData):
         "__rshift__": operator.rshift,
     }
 
-    # Create both left- and right-hand versions of each operator
     for _name, _op in _arith_ops.items():
 
         def _make(op):
@@ -243,6 +254,24 @@ class Param(MessageData):
             return self
         return self.default
 
+    def __json__(self):
+        return self.default if not hasattr(self.default, '__json__') else self.default.__json__()
+
+    @classmethod
+    def _patch_encoder(cls):
+        # only patch once
+        if getattr(json.JSONEncoder, "_user_patched", False):
+            return
+        original = json.JSONEncoder.default
+
+        def default(self, obj):
+            if isinstance(obj, Param):
+                return obj.__json__()
+            return original(self, obj)
+
+        json.JSONEncoder.default = default
+        json.JSONEncoder._user_patched = True
+
     def to_proto(self, proto=None) -> ParamProto:
         if proto is None:
             proto = ParamProto()
@@ -254,7 +283,7 @@ class Param(MessageData):
                 option = ModelTypeEnumOption(id=str(choice))
                 proto.model_type_enum_options.append(option)
 
-        proto.required = self.default is None
+        proto.required = False
 
         if self.min_value is not None or self.max_value is not None:
             range_info = ModelTypeRangeInfo()
@@ -324,8 +353,7 @@ class Param(MessageData):
 
             if proto is None:
                 proto = ParamProto()
-            if default is not None:
-                proto.default = json.dumps(default)
+            proto.default = json.dumps(default)
             return proto
         except Exception:
             if default is not None:

clarifai/runners/utils/loader.py

@@ -41,7 +41,7 @@ class HuggingFaceLoader:
             return True
         except Exception as e:
             logger.error(
-                f"Error setting up Hugging Face token, please make sure you have the correct token: {e}"
+                f"Invalid Hugging Face token provided in the config file, this might cause issues with downloading the restricted model checkpoints. Failed reason: {e}"
             )
             return False
 
@@ -63,7 +63,6 @@ class HuggingFaceLoader:
             try:
                 is_hf_model_exists = self.validate_hf_model()
                 if not is_hf_model_exists:
-                    logger.error("Model %s not found on Hugging Face" % (self.repo_id))
                     return False
 
                 self.ignore_patterns = self._get_ignore_patterns()
@@ -205,6 +204,28 @@ class HuggingFaceLoader:
             ]
         return self.ignore_patterns
 
+    @classmethod
+    def validate_hf_repo_access(cls, repo_id: str, token: str = None) -> bool:
+        # check if model exists on HF
+        try:
+            from huggingface_hub import auth_check
+            from huggingface_hub.utils import GatedRepoError, RepositoryNotFoundError
+        except ImportError:
+            raise ImportError(cls.HF_DOWNLOAD_TEXT)
+
+        try:
+            auth_check(repo_id, token=token)
+            logger.info("Hugging Face repo access validated")
+            return True
+        except GatedRepoError:
+            logger.error(
+                "Hugging Face repo is gated. Please make sure you have access to the repo."
+            )
+            return False
+        except RepositoryNotFoundError:
+            logger.error("Hugging Face repo not found. Please make sure the repo exists.")
+            return False
+
     @staticmethod
     def validate_config(checkpoint_path: str):
         # check if downloaded config.json exists

clarifai/runners/utils/method_signatures.py

@@ -302,6 +302,9 @@ def serialize(kwargs, signatures, proto=None, is_output=False):
                 raise TypeError(f'Missing required argument: {sig.name}')
             continue  # skip missing fields, they can be set to default on the server
         data = kwargs[sig.name]
+        default = data_utils.Param.get_default(sig)
+        if data is None and default is None:
+            continue
         serializer = serializer_from_signature(sig)
         # TODO determine if any (esp the first) var can go in the proto without parts
         # and whether to put this in the signature or dynamically determine it
@@ -312,7 +315,7 @@ def serialize(kwargs, signatures, proto=None, is_output=False):
     return proto
 
 
-def deserialize(proto, signatures, inference_params={}, is_output=False):
+def deserialize(proto, signatures, is_output=False):
     '''
     Deserialize the given proto into kwargs using the given signatures.
     '''
@@ -323,11 +326,8 @@ def deserialize(proto, signatures, inference_params={}, is_output=False):
     for sig_i, sig in enumerate(signatures):
         serializer = serializer_from_signature(sig)
         part = parts_by_name.get(sig.name)
-        inference_params_value = inference_params.get(sig.name)
         if part is not None:
             kwargs[sig.name] = serializer.deserialize(part.data)
-        elif inference_params_value is not None:
-            kwargs[sig.name] = inference_params_value
         else:
             if sig_i == 0:
                 # possible inlined first value

clarifai/utils/config.py

@@ -102,6 +102,25 @@ class Context(OrderedDict):
                 envvar_name = 'CLARIFAI_' + envvar_name
             os.environ[envvar_name] = str(v)
 
+    def print_env_vars(self):
+        """prints the context env vars to the terminal
+
+        Example:
+          # This is helpful in scripts so you can do
+
+          from clarifai.utils.config import Config
+
+          Config.from_yaml().current.print_env_vars()
+
+        """
+        for k, v in self['env'].items():
+            if isinstance(v, dict):
+                continue
+            envvar_name = k.upper()
+            if not envvar_name.startswith('CLARIFAI_'):
+                envvar_name = 'CLARIFAI_' + envvar_name
+            print(f"export {envvar_name}=\"{v}\"")
+
 
 @dataclass
 class Config:

clarifai/utils/config.py~

@@ -0,0 +1,145 @@
+import click
+import sys
+import os
+import typing as t
+import yaml
+
+from dataclasses import dataclass, field
+from clarifai.utils.cli import AliasedGroup, TableFormatter, load_command_modules, load_command_modules
+
+
+
+@dataclass
+class AccessToken():
+  type: str
+  value: str
+
+  def __str__(self):
+    return f'{self.type}:{self.value}' if self.type == 'env' else '********'
+
+  def to_serializable_dict(self):
+    return self.__dict__
+
+  @classmethod
+  def from_serializable_dict(cls, _dict):
+    return cls(**_dict)
+
+  # Dictionary protocol methods:
+
+  def __getitem__(self, key: str) -> t.Any:
+    if key == 'type':
+      return self.type
+    elif key == 'value':
+      return self.value
+    else:
+      raise KeyError(key)
+
+  def __setitem__(self, key: str, value: t.Any) -> None:
+    if key == 'type':
+      self.type = value
+    elif key == 'value':
+      self.value = value
+    else:
+      raise KeyError(key)
+
+  def __delitem__(self, key: str) -> None:
+    raise TypeError("Cannot delete attributes from AccessToken")
+
+  def __iter__(self):
+    return iter(['type', 'value'])
+
+  def __len__(self) -> int:
+    return 2
+
+  def __contains__(self, key: str) -> bool:
+    return key in ['type', 'value']
+
+  def keys(self):
+    return ['type', 'value']
+
+  def values(self):
+    return [self.type, self.value]
+
+  def items(self):
+    return [('type', self.type), ('value', self.value)]
+
+  def get(self, key: str, default: t.Any = None) -> t.Any:
+    try:
+      return self[key]
+    except KeyError:
+      return default
+
+
+@dataclass
+class Context():
+  name: str
+  user_id: str
+  base_url: str
+  access_token: AccessToken = field(default_factory=lambda: AccessToken('env', 'CLARIFAI_PAT'))
+  env: t.Dict[str, str] = field(default_factory=dict)
+
+  pat: str = None
+
+  def _resolve_pat(self) -> str:
+    if self.access_token['type'].lower() == 'env':
+      return os.getenv(self.access_token['value'], '')
+    elif self.access_token['type'].lower() == 'raw':
+      return self.access_token['value']
+    else:
+      raise Exception('Only "env" and "raw" methods are supported')
+
+  def __post_init__(self):
+    self.pat = self._resolve_pat()
+    self.access_token = AccessToken(**self.access_token)
+
+  def to_serializable_dict(self):
+    result = {
+        'name': self.name,
+        'user_id': self.user_id,
+        'base_url': self.base_url,
+        'access_token': self.access_token.to_serializable_dict(),
+    }
+    if self.env:
+      result['env'] = self.env
+    return result
+
+
+@dataclass
+class Config():
+  current_context: str
+  filename: str
+  contexts: dict[str, Context] = field(default_factory=dict)
+
+  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)
+
+  def current(self) -> Context:
+    return self.contexts[self.current_context]

clarifai/utils/logging.py

@@ -10,6 +10,8 @@ import traceback
 from collections import defaultdict
 from typing import Any, Dict, List, Optional, Union
 
+from clarifai.errors import UserError
+
 # The default logger to use throughout the SDK is defined at bottom of this file.
 
 # For the json logger.
@@ -80,8 +82,13 @@ 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
+    try:
+        from rich import print as rprint
+        from rich.tree import Tree
+    except ImportError:
+        raise UserError(
+            "Rich library is not installed. Please install it using pip install rich>=13.4.2"
+        )
 
     # Create a mapping of node_id to the list of node_ids that are connected to it.
     node_adj_mapping = defaultdict(list)
@@ -131,7 +138,12 @@ def display_workflow_tree(nodes_data: List[Dict]) -> None:
 
 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
+    try:
+        from rich.table import Table
+    except ImportError:
+        raise UserError(
+            "Rich library is not installed. Please install it using pip install rich>=13.4.2"
+        )
 
     table = Table(title=title, show_lines=False, show_header=True, header_style="blue")
     for column_name in column_names:
@@ -233,8 +245,13 @@ 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
+    try:
+        from rich import print as rprint
+        from rich.tree import Tree
+    except ImportError:
+        raise UserError(
+            "Rich library is not installed. Please install it using pip install rich>=13.4.2"
+        )
 
     for parent, children in relations_dict.items():
         tree = Tree(parent)