clarifai 11.3.0rc2__py3-none-any.whl → 11.4.0__py3-none-any.whl

clarifai/runners/utils/data_handler.py

@@ -1,231 +0,0 @@
-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

@@ -1,213 +0,0 @@
-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.
-
-'''