clarifai 11.6.4rc1__py3-none-any.whl → 11.6.5__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_types.py

@@ -1,471 +0,0 @@
-import io
-import json
-from typing import Iterable, List, get_args, get_origin
-
-import numpy as np
-from clarifai_grpc.grpc.api.resources_pb2 import Audio as AudioProto
-from clarifai_grpc.grpc.api.resources_pb2 import Concept as ConceptProto
-from clarifai_grpc.grpc.api.resources_pb2 import Frame as FrameProto
-from clarifai_grpc.grpc.api.resources_pb2 import Image as ImageProto
-from clarifai_grpc.grpc.api.resources_pb2 import Region as RegionProto
-from clarifai_grpc.grpc.api.resources_pb2 import Text as TextProto
-from clarifai_grpc.grpc.api.resources_pb2 import Video as VideoProto
-from PIL import Image as PILImage
-
-
-class MessageData:
-    def to_proto(self):
-        raise NotImplementedError
-
-    @classmethod
-    def from_proto(cls, proto):
-        raise NotImplementedError
-
-    @classmethod
-    def from_value(cls, value):
-        if isinstance(value, cls):
-            return value
-        return cls(value)
-
-    def cast(self, python_type):
-        if python_type is self.__class__:
-            return self
-        raise TypeError(f'Incompatible type for {self.__class__.__name__}: {python_type}')
-
-
-class NamedFieldsMeta(type):
-    """Metaclass to create NamedFields subclasses with __annotations__ when fields are specified."""
-
-    def __call__(cls, *args, **kwargs):
-        # Check if keyword arguments are types (used in type annotations)
-        if kwargs and all(isinstance(v, type) for v in kwargs.values()):
-            # Dynamically create a subclass with __annotations__
-            name = f"NamedFields({', '.join(f'{k}:{v.__name__}' for k, v in kwargs.items())})"
-            return type(name, (cls,), {'__annotations__': kwargs})
-        else:
-            # Create a normal instance for runtime data
-            return super().__call__(*args, **kwargs)
-
-
-class NamedFields(metaclass=NamedFieldsMeta):
-    """A class that can be used to store named fields with values."""
-
-    def __init__(self, **kwargs):
-        for key, value in kwargs.items():
-            setattr(self, key, value)
-
-    def items(self):
-        return self.__dict__.items()
-
-    def keys(self):
-        return self.__dict__.keys()
-
-    def values(self):
-        return self.__dict__.values()
-
-    def __contains__(self, key):
-        return key in self.__dict__
-
-    def __getitem__(self, key):
-        return getattr(self, key)
-
-    def __setitem__(self, key, value):
-        setattr(self, key, value)
-
-    def __repr__(self):
-        return f"{self.__class__.__name__}({', '.join(f'{key}={value!r}' for key, value in self.__dict__.items())})"
-
-    def __origin__(self):
-        return self
-
-    def __args__(self):
-        return list(self.keys())
-
-
-class JSON:
-    def __init__(self, value):
-        self.value = value
-
-    def __eq__(self, other):
-        return self.value == other
-
-    def __bool__(self):
-        return bool(self.value)
-
-    def __repr__(self):
-        return f"JSON({self.value})"
-
-    def to_json(self):
-        return json.dumps(self.value)
-
-    @classmethod
-    def from_json(cls, json_str):
-        return cls(json.loads(json_str))
-
-    @classmethod
-    def from_value(cls, value):
-        return cls(value)
-
-    def cast(self, python_type):
-        if not isinstance(self.value, python_type):
-            raise TypeError(f'Incompatible type {type(self.value)} for {python_type}')
-        return self.value
-
-
-class Text(MessageData):
-    def __init__(self, text: str, url: str = None):
-        self.text = text
-        self.url = url
-
-    def __eq__(self, other):
-        if isinstance(other, Text):
-            return self.text == other.text and self.url == other.url
-        if isinstance(other, str):
-            return self.text == other
-        return False
-
-    def __bool__(self):
-        return bool(self.text) or bool(self.url)
-
-    def __repr__(self) -> str:
-        return f"Text(text={self.text!r}, url={self.url!r})"
-
-    def to_proto(self) -> TextProto:
-        return TextProto(raw=self.text or '', url=self.url or '')
-
-    @classmethod
-    def from_proto(cls, proto: TextProto) -> "Text":
-        return cls(proto.raw, proto.url or None)
-
-    @classmethod
-    def from_value(cls, value):
-        if isinstance(value, str):
-            return cls(value)
-        if isinstance(value, Text):
-            return value
-        if isinstance(value, dict):
-            return cls(value.get('text'), value.get('url'))
-        raise TypeError(f'Incompatible type for Text: {type(value)}')
-
-    def cast(self, python_type):
-        if python_type is str:
-            return self.text
-        if python_type is Text:
-            return self
-        raise TypeError(f'Incompatible type for Text: {python_type}')
-
-
-class Concept(MessageData):
-    def __init__(self, name: str, value: float = 1):
-        self.id = name
-        self.name = name
-        self.value = value
-
-    def __repr__(self) -> str:
-        return f"Concept(id={self.id!r}, name={self.name!r}, value={self.value})"
-
-    def to_proto(self):
-        return ConceptProto(id=self.id, name=self.name, value=self.value)
-
-    @classmethod
-    def from_proto(cls, proto: ConceptProto) -> "Concept":
-        return cls(proto.name, proto.value)
-
-
-class Region(MessageData):
-    def __init__(
-        self,
-        proto_region: RegionProto = None,
-        box: List[float] = None,
-        concepts: List[Concept] = None,
-    ):
-        if proto_region is None:
-            proto_region = RegionProto()
-        self.proto = proto_region
-        # use setters for init vals
-        if (
-            box
-            and isinstance(box, list)
-            and len(box) == 4
-            and all(isinstance(val, (int, float)) for val in box)
-        ):
-            self.box = box
-        if (
-            concepts
-            and isinstance(concepts, list)
-            and all(isinstance(concept, Concept) for concept in concepts)
-        ):
-            self.concepts = concepts
-
-    @property
-    def box(self) -> List[float]:
-        bbox = self.proto.region_info.bounding_box
-        return [bbox.left_col, bbox.top_row, bbox.right_col, bbox.bottom_row]  # x1, y1, x2, y2
-
-    @box.setter
-    def box(self, value: List[float]):
-        bbox = self.proto.region_info.bounding_box
-        bbox.left_col, bbox.top_row, bbox.right_col, bbox.bottom_row = value
-
-    @property
-    def concepts(self) -> List[Concept]:
-        return [Concept.from_proto(proto) for proto in self.proto.data.concepts]
-
-    @concepts.setter
-    def concepts(self, value: List[Concept]):
-        self.proto.data.concepts.extend([concept.to_proto() for concept in value])
-
-    def __repr__(self) -> str:
-        return f"Region(box={self.box}, concepts={self.concepts})"
-
-    def to_proto(self) -> RegionProto:
-        return self.proto
-
-    @classmethod
-    def from_proto(cls, proto: RegionProto) -> "Region":
-        return cls(proto)
-
-
-class Image(MessageData):
-    def __init__(self, proto_image: ImageProto = None, url: str = None, bytes: bytes = None):
-        if proto_image is None:
-            proto_image = ImageProto()
-        self.proto = proto_image
-        # use setters for init vals
-        if url:
-            self.url = url
-        if bytes:
-            self.bytes = bytes
-
-    @property
-    def url(self) -> str:
-        return self.proto.url
-
-    @url.setter
-    def url(self, value: str):
-        self.proto.url = value
-
-    @property
-    def bytes(self) -> bytes:
-        return self.proto.base64
-
-    @bytes.setter
-    def bytes(self, value: bytes):
-        self.proto.base64 = value
-
-    def __repr__(self) -> str:
-        attrs = []
-        if self.url:
-            attrs.append(f"url={self.url!r}")
-        if self.bytes:
-            attrs.append(f"bytes=<{len(self.bytes)} bytes>")
-        return f"Image({', '.join(attrs)})"
-
-    @classmethod
-    def from_url(cls, url: str) -> "Image":
-        proto_image = ImageProto(url=url)
-        return cls(proto_image)
-
-    @classmethod
-    def from_pil(cls, pil_image: PILImage.Image) -> "Image":
-        with io.BytesIO() as output:
-            pil_image.save(output, format="PNG")
-            image_bytes = output.getvalue()
-        proto_image = ImageProto(base64=image_bytes)
-        return cls(proto_image)
-
-    def to_pil(self) -> PILImage.Image:
-        if not self.proto.base64:
-            raise ValueError("Image has no bytes")
-        return PILImage.open(io.BytesIO(self.proto.base64))
-
-    def to_numpy(self) -> np.ndarray:
-        return np.asarray(self.to_pil())
-
-    def to_proto(self) -> ImageProto:
-        return self.proto
-
-    @classmethod
-    def from_proto(cls, proto: ImageProto) -> "Image":
-        return cls(proto)
-
-    @classmethod
-    def from_value(cls, value):
-        if isinstance(value, PILImage.Image):
-            return cls.from_pil(value)
-        if isinstance(value, Image):
-            return value
-        raise TypeError(f'Incompatible type for Image: {type(value)}')
-
-    def cast(self, python_type):
-        if python_type is Image:
-            return self
-        if python_type is PILImage.Image or python_type is PILImage:
-            return self.to_pil()
-        if python_type is np.ndarray or get_origin(python_type) is np.ndarray:
-            return self.to_numpy()
-        raise TypeError(f'Incompatible type for Image: {python_type}')
-
-
-class Audio(MessageData):
-    def __init__(self, proto_audio: AudioProto = None, url: str = None, bytes: bytes = None):
-        if proto_audio is None:
-            proto_audio = AudioProto()
-        self.proto = proto_audio
-
-        if url:
-            self.url = url
-        if bytes:
-            self.bytes = bytes
-
-    @property
-    def url(self) -> str:
-        return self.proto.url
-
-    @url.setter
-    def url(self, value: str):
-        self.proto.url = value
-
-    @property
-    def bytes(self) -> bytes:
-        return self.proto.base64
-
-    @bytes.setter
-    def bytes(self, value: bytes):
-        self.proto.base64 = value
-
-    @classmethod
-    def from_url(cls, url: str) -> "Audio":
-        proto_audio = AudioProto(url=url)
-        return cls(proto_audio)
-
-    def __repr__(self) -> str:
-        attrs = []
-        if self.url:
-            attrs.append(f"url={self.url!r}")
-        if self.bytes:
-            attrs.append(f"bytes=<{len(self.bytes)} bytes>")
-        return f"Audio({', '.join(attrs)})"
-
-    def to_proto(self) -> AudioProto:
-        return self.proto
-
-    @classmethod
-    def from_proto(cls, proto: AudioProto) -> "Audio":
-        return cls(proto)
-
-
-class Frame(MessageData):
-    def __init__(
-        self,
-        proto_frame: FrameProto = None,
-        image: Image = None,
-        regions: List[Region] = None,
-        time: float = None,
-    ):
-        if proto_frame is None:
-            proto_frame = FrameProto()
-        self.proto = proto_frame
-        # use setters for init vals
-        if image:
-            self.image = image
-        if regions:
-            self.regions = regions
-        if time:
-            self.time = time
-
-    @property
-    def time(self) -> float:
-        # TODO: time is a uint32, so this will overflow at 49.7 days
-        # we should be using double or uint64 in the proto instead
-        return self.proto.frame_info.time / 1000.0
-
-    @time.setter
-    def time(self, value: float):
-        self.proto.frame_info.time = int(value * 1000)
-
-    @property
-    def image(self) -> Image:
-        return Image.from_proto(self.proto.data.image)
-
-    @image.setter
-    def image(self, value: Image):
-        self.proto.data.image.CopyFrom(value.to_proto())
-
-    @property
-    def regions(self) -> List[Region]:
-        return [Region(region) for region in self.proto.data.regions]
-
-    @regions.setter
-    def regions(self, value: List[Region]):
-        self.proto.data.regions.extend([region.proto for region in value])
-
-    def to_proto(self) -> FrameProto:
-        return self.proto
-
-    @classmethod
-    def from_proto(cls, proto: FrameProto) -> "Frame":
-        return cls(proto)
-
-
-class Video(MessageData):
-    def __init__(self, proto_video: VideoProto = None, url: str = None, bytes: bytes = None):
-        if proto_video is None:
-            proto_video = VideoProto()
-        self.proto = proto_video
-
-        if url:
-            self.url = url
-        if bytes:
-            self.bytes = bytes
-
-    @property
-    def url(self) -> str:
-        return self.proto.url
-
-    @url.setter
-    def url(self, value: str):
-        self.proto.url = value
-
-    @property
-    def bytes(self) -> bytes:
-        return self.proto.base64
-
-    @bytes.setter
-    def bytes(self, value: bytes):
-        self.proto.base64 = value
-
-    @classmethod
-    def from_url(cls, url: str) -> "Video":
-        proto_video = VideoProto(url=url)
-        return cls(proto_video)
-
-    def __repr__(self) -> str:
-        attrs = []
-        if self.url:
-            attrs.append(f"url={self.url!r}")
-        if self.bytes:
-            attrs.append(f"bytes=<{len(self.bytes)} bytes>")
-        return f"Video({', '.join(attrs)})"
-
-    def to_proto(self) -> VideoProto:
-        return self.proto
-
-    @classmethod
-    def from_proto(cls, proto: VideoProto) -> "Video":
-        return cls(proto)
-
-
-def cast(value, python_type):
-    list_type = get_origin(python_type) is list
-    if isinstance(value, MessageData):
-        return value.cast(python_type)
-    if list_type and isinstance(value, np.ndarray):
-        return value.tolist()
-    if list_type and isinstance(value, list):
-        if get_args(python_type):
-            inner_type = get_args(python_type)[0]
-            return [cast(item, inner_type) for item in value]
-        if not isinstance(value, Iterable):
-            raise TypeError(f'Expected list, got {type(value)}')
-    return value