clarifai 11.3.0__py3-none-any.whl → 11.3.0rc2__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_handler_refract.py

@@ -0,0 +1,213 @@
+import io
+from typing import Any, Callable, Dict, Type
+
+import numpy as np
+from clarifai_grpc.grpc.api import resources_pb2
+from clarifai_grpc.grpc.api.resources_pb2 import Audio as AudioProto
+from clarifai_grpc.grpc.api.resources_pb2 import Image as ImageProto
+from clarifai_grpc.grpc.api.resources_pb2 import NDArray
+from clarifai_grpc.grpc.api.resources_pb2 import Text as TextProto
+from clarifai_grpc.grpc.api.resources_pb2 import Video as VideoProto
+from google.protobuf.json_format import MessageToDict, ParseDict
+from google.protobuf.struct_pb2 import Struct
+from PIL import Image as PILImage
+
+# Type registry for conversion between Python types and protobuf
+_TYPE_HANDLERS: Dict[Type, Callable] = {
+    # Python type: (to_proto, from_proto)
+    TextProto: (
+        lambda value: value.to_proto(),
+        lambda proto: Text.from_proto(proto)
+    ),
+    ImageProto: (
+        lambda value: value.to_proto(),
+        lambda proto: Image(proto)
+    ),
+    AudioProto: (
+        lambda value: value.to_proto(),
+        lambda proto: Audio(proto)
+    ),
+    VideoProto: (
+        lambda value: value.to_proto(),
+        lambda proto: Video(proto)
+    ),
+    str: (
+        lambda value: TextProto(raw=value),
+        lambda proto: proto.raw
+    ),
+    bytes: (
+        lambda value: resources_pb2.Data(base64=value),
+        lambda proto: proto.base64
+    ),
+    int: (
+        lambda value: resources_pb2.Data(int_value=value),
+        lambda proto: proto.int_value
+    ),
+    float: (
+        lambda value: resources_pb2.Data(float_value=value),
+        lambda proto: proto.float_value
+    ),
+    bool: (
+        lambda value: resources_pb2.Data(boolean=value),
+        lambda proto: proto.boolean
+    ),
+    np.ndarray: (
+        lambda value: NDArray(buffer=value.tobytes(), shape=value.shape, dtype=str(value.dtype)),
+        lambda proto: np.frombuffer(proto.buffer, dtype=np.dtype(proto.dtype)).reshape(proto.shape)
+    ),
+    PILImage.Image: (
+        lambda value: Image.from_pil(value).to_proto(),
+        lambda proto: Image(proto).to_pil()
+    ),
+    dict: (
+        lambda value: _dict_to_metadata(value),
+        lambda proto: MessageToDict(proto.metadata)
+    )
+}
+
+
+def _dict_to_metadata(metadata: dict) -> Struct:
+  struct = Struct()
+  ParseDict(metadata, struct)
+  return struct
+
+
+def _value_to_proto(value: Any) -> resources_pb2.Data:
+  """Convert a Python value to a protobuf Data message."""
+  data = resources_pb2.Data()
+  for py_type, (to_proto, _) in _TYPE_HANDLERS.items():
+    if isinstance(value, py_type):
+      handler = to_proto
+      break
+  else:
+    if isinstance(value, (Text, Image, Audio, Video)):
+      data_part = getattr(data, type(value).__name__.lower())
+      data_part.CopyFrom(value.to_proto())
+      return data
+    raise TypeError(f"Unsupported type: {type(value)}")
+
+  result = handler(value)
+  if isinstance(result, resources_pb2.Data):
+    data.CopyFrom(result)
+  else:
+    field_name = type(result).DESCRIPTOR.name.lower()
+    getattr(data, field_name).CopyFrom(result)
+  return data
+
+
+def _proto_to_value(proto: resources_pb2.Data) -> Any:
+  """Convert a protobuf Data message to a Python value."""
+  for field in proto.DESCRIPTOR.fields:
+    if proto.HasField(field.name):
+      _, from_proto = _TYPE_HANDLERS.get(field.type, (None, None))
+      if from_proto:
+        return from_proto(getattr(proto, field.name))
+  if proto.parts:
+    return [_proto_to_value(part.data) for part in proto.parts]
+  return None
+
+
+def kwargs_to_proto(**kwargs) -> resources_pb2.Data:
+  """Convert keyword arguments to a Data proto."""
+  data_proto = resources_pb2.Data()
+  for part_name, part_value in kwargs.items():
+    part = data_proto.parts.add()
+    part.id = part_name
+
+    if isinstance(part_value, list):
+      for item in part_value:
+        item_proto = _value_to_proto(item)
+        part_part = part.data.parts.add()
+        part_part.data.CopyFrom(item_proto)
+    else:
+      part_proto = _value_to_proto(part_value)
+      part.data.CopyFrom(part_proto)
+  return data_proto
+
+
+def proto_to_kwargs(data: resources_pb2.Data) -> dict:
+  """Convert a Data proto to keyword arguments."""
+  kwargs = {}
+  for part in data.parts:
+    part_name = part.id
+    if part.data.parts:
+      kwargs[part_name] = [_proto_to_value(part.data) for _ in part.data.parts]
+    else:
+      kwargs[part_name] = _proto_to_value(part.data)
+  return kwargs
+
+
+class Output:
+
+  def __init__(self, **kwargs: Any):
+    if not kwargs:
+      raise ValueError("Output must have at least one key-value pair")
+    self.parts = kwargs
+
+  def to_proto(self) -> resources_pb2.Output:
+    data_proto = kwargs_to_proto(**self.parts)
+    return resources_pb2.Output(data=data_proto)
+
+
+class Text:
+
+  def __init__(self, text: str):
+    self.text = text
+
+  def to_proto(self) -> TextProto:
+    return TextProto(raw=self.text)
+
+  @classmethod
+  def from_proto(cls, proto: TextProto) -> "Text":
+    return cls(proto.raw)
+
+
+class Image:
+
+  def __init__(self, proto_image: ImageProto):
+    self.proto = proto_image
+
+  @classmethod
+  def from_url(cls, url: str) -> "Image":
+    return cls(ImageProto(url=url))
+
+  @classmethod
+  def from_pil(cls, pil_image: PILImage.Image) -> "Image":
+    with io.BytesIO() as output:
+      pil_image.save(output, format="PNG")
+      return cls(ImageProto(base64=output.getvalue()))
+
+  def to_pil(self) -> PILImage.Image:
+    return PILImage.open(io.BytesIO(self.proto.base64))
+
+  def to_proto(self) -> ImageProto:
+    return self.proto
+
+
+class Audio:
+
+  def __init__(self, proto_audio: AudioProto):
+    self.proto = proto_audio
+
+  def to_proto(self) -> AudioProto:
+    return self.proto
+
+
+class Video:
+
+  def __init__(self, proto_video: VideoProto):
+    self.proto = proto_video
+
+  def to_proto(self) -> VideoProto:
+    return self.proto
+
+
+'''
+Type Handling Registry: Centralized conversion logic reduces duplication and enhances extensibility.
+Simplified Conversion Functions: _value_to_proto and _proto_to_value handle all type conversions using the registry.
+Streamlined Wrapper Methods: Common processing logic extracted into _process_request, reducing code duplication.
+Improved Batch Processing: Uses ThreadPoolExecutor.map for cleaner batch prediction.
+Error Handling: Clearer error messages and validation of required parameters.
+Removed Redundant Checks: Simplified Output class initialization.
+
+'''

clarifai/runners/utils/data_utils.py

@@ -1,3 +1,4 @@
+import operator
 from io import BytesIO
 from typing import List
 
@@ -61,21 +62,19 @@ def is_openai_chat_format(messages):
 class InputField(MessageData):
   """A field that can be used to store input data."""
 
-  def __init__(
-      self,
-      default=None,
-      description=None,
-      min_value=None,
-      max_value=None,
-      choices=None,
-      #  is_param=True
-  ):
+  def __init__(self,
+               default=None,
+               description=None,
+               min_value=None,
+               max_value=None,
+               choices=None,
+               is_param=True):
     self.default = default
     self.description = description
     self.min_value = min_value
     self.max_value = max_value
     self.choices = choices
-    # self.is_param = is_param
+    self.is_param = is_param
 
   def __repr__(self) -> str:
     attrs = []
@@ -89,9 +88,104 @@ class InputField(MessageData):
       attrs.append(f"max_value={self.max_value!r}")
     if self.choices is not None:
       attrs.append(f"choices={self.choices!r}")
-    # attrs.append(f"is_param={self.is_param!r}")
+    attrs.append(f"is_param={self.is_param!r}")
     return f"InputField({', '.join(attrs)})"
 
+  # All *explicit* conversions
+  def __int__(self):
+    return int(self.default)
+
+  def __float__(self):
+    return float(self.default)
+
+  def __str__(self):
+    return str(self.default)
+
+  def __bool__(self):
+    return bool(self.default)
+
+  def __index__(self):
+    return int(self.default)  # for slicing
+
+  # sequence / mapping protocol delegation
+  def __len__(self):
+    return len(self.default)
+
+  def __iter__(self):
+    return iter(self.default)
+
+  def __reversed__(self):
+    return reversed(self.default)
+
+  def __contains__(self, item):
+    return item in self.default
+
+  def __getitem__(self, key):
+    return self.default[key]
+
+  def __setitem__(self, k, v):
+    self.default[k] = v
+
+  def __delitem__(self, k):
+    del self.default[k]
+
+  def __hash__(self):
+    return hash(self.default)
+
+  def __call__(self, *args, **kwargs):
+    return self.default(*args, **kwargs)
+
+  # Comparison operators
+  def __eq__(self, other):
+    return self.default == other
+
+  def __lt__(self, other):
+    return self.default < other
+
+  def __le__(self, other):
+    return self.default <= other
+
+  def __gt__(self, other):
+    return self.default > other
+
+  def __ge__(self, other):
+    return self.default >= other
+
+  # Arithmetic operators – # arithmetic & bitwise operators – auto-generated
+  _arith_ops = {
+      "__add__": operator.add,
+      "__sub__": operator.sub,
+      "__mul__": operator.mul,
+      "__truediv__": operator.truediv,
+      "__floordiv__": operator.floordiv,
+      "__mod__": operator.mod,
+      "__pow__": operator.pow,
+      "__and__": operator.and_,
+      "__or__": operator.or_,
+      "__xor__": operator.xor,
+      "__lshift__": operator.lshift,
+      "__rshift__": operator.rshift,
+  }
+
+  # Create both left- and right-hand versions of each operator
+  for _name, _op in _arith_ops.items():
+
+    def _make(op):
+
+      def _f(self, other, *, _op=op):  # default arg binds op
+        return _op(self.default, other)
+
+      return _f
+
+    locals()[_name] = _make(_op)
+    locals()["__r" + _name[2:]] = _make(lambda x, y, _op=_op: _op(y, x))
+  del _name, _op, _make
+
+  # Attribute access delegation – anything we did *not* define above
+  # will automatically be looked up on the wrapped default value.
+  def __getattr__(self, item):
+    return getattr(self.default, item)
+
   def to_proto(self, proto=None) -> InputFieldProto:
     if proto is None:
       proto = InputFieldProto()
@@ -112,7 +206,7 @@ class InputField(MessageData):
       if self.max_value is not None:
         range_info.max = float(self.max_value)
       proto.model_type_range_info.CopyFrom(range_info)
-    # proto.is_param = self.is_param
+    proto.is_param = self.is_param
 
     if self.default is not None:
       proto = self.set_default(proto, self.default)
@@ -159,8 +253,7 @@ class InputField(MessageData):
         min_value=min_value,
         max_value=max_value,
         choices=choices,
-        # is_param=proto.is_param
-    )
+        is_param=proto.is_param)
 
   @classmethod
   def set_default(cls, proto=None, default=None):