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

clarifai/runners/utils/data_handler.py

@@ -1,292 +0,0 @@
-import io
-from typing import Any
-
-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 Text as TextProto
-from clarifai_grpc.grpc.api.resources_pb2 import Video as VideoProto
-from clarifai_grpc.grpc.api.status import status_code_pb2, status_pb2
-from google.protobuf.json_format import MessageToDict, ParseDict
-from google.protobuf.struct_pb2 import Struct
-from PIL import Image as PILImage
-
-
-def metadata_to_dict(data: resources_pb2.Data) -> dict:
-  return MessageToDict(data.metadata)
-
-
-def dict_to_metadata(data: resources_pb2.Data, metadata_dict: dict):
-  struct = Struct()
-  ParseDict(metadata_dict, struct)
-  data.metadata.CopyFrom(struct)
-
-
-def kwargs_to_proto(*args, **kwargs) -> resources_pb2.Data:
-  """Converts the kwargs to a Clarifai protobuf Data message."""
-
-  kwargs = dict(kwargs)
-  if any(k.startswith("_arg_") for k in kwargs.keys()):
-    raise ValueError("Keys starting with '_arg_' are reserved for positional arguments")
-  for arg_i, arg in enumerate(args):
-    kwargs[f"_arg_{arg_i}"] = arg
-
-  def _handle_list(target_data, value_list, part_name):
-    """Handles list values by processing each item into a new part."""
-    if isinstance(value_list[0], dict):
-      raise ValueError("List of dictionaries is not supported")
-
-    for item in value_list:
-      new_part = target_data.parts.add()
-      _process_value(new_part.data, item, part_name)
-
-  def _process_value(target_data, value, part_name):
-    """Processes individual values and sets the appropriate proto field."""
-    if isinstance(value, Text):
-      target_data.text.CopyFrom(value.to_proto())
-    elif isinstance(value, Image):
-      target_data.image.CopyFrom(value.to_proto())
-    elif isinstance(value, Audio):
-      target_data.audio.CopyFrom(value.to_proto())
-    elif isinstance(value, Video):
-      target_data.video.CopyFrom(value.to_proto())
-    elif isinstance(value, str):
-      target_data.text.raw = value
-    elif isinstance(value, bytes):
-      target_data.bytes_value = value
-    elif isinstance(value, int):
-      target_data.int_value = value
-    elif isinstance(value, float):
-      target_data.float_value = value
-    elif isinstance(value, bool):
-      target_data.bool_value = value
-    elif isinstance(value, np.ndarray):
-      ndarray_proto = resources_pb2.NDArray(
-          buffer=value.tobytes(), shape=value.shape, dtype=str(value.dtype))
-      target_data.ndarray.CopyFrom(ndarray_proto)
-    elif isinstance(value, PILImage.Image):
-      image = Image.from_pil(value)
-      target_data.image.CopyFrom(image.to_proto())
-    else:
-      raise TypeError(f"Unsupported type {type(value)} for part '{part_name}'")
-
-  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):
-      _handle_list(part.data, part_value, part_name)
-    elif isinstance(part_value, dict):
-      dict_to_metadata(part.data, part_value)
-    else:
-      _process_value(part.data, part_value, part_name)
-  return data_proto
-
-
-def proto_to_kwargs(data: resources_pb2.Data) -> dict:
-  """Converts the Clarifai protobuf Data message to a dictionary."""
-
-  def process_part(part, allow_metadata: bool = True) -> object:
-    if part.HasField("text"):
-      return Text.from_proto(part.text).text
-    elif part.HasField("image"):
-      return Image(part.image)
-    elif part.HasField("audio"):
-      return Audio(part.audio)
-    elif part.HasField("video"):
-      return Video(part.video)
-    elif part.bytes_value != b'':
-      return part.bytes_value
-    elif part.int_value != 0:
-      return part.int_value
-    elif part.float_value != 0.0:
-      return part.float_value
-    elif part.bool_value is not False:
-      return part.bool_value
-    elif part.HasField("ndarray"):
-      ndarray = part.ndarray
-      return np.frombuffer(ndarray.buffer, dtype=np.dtype(ndarray.dtype)).reshape(ndarray.shape)
-    elif part.HasField("metadata"):
-      if not allow_metadata:
-        raise ValueError("Metadata in list is not supported")
-      return metadata_to_dict(part)
-    elif part.parts:
-      return [process_part(p.data,) for p in part.parts]
-    else:
-      raise ValueError(f"Unknown part data: {part}")
-
-  kwargs = {}
-  part_names = [part.id for part in data.parts]
-  assert "return" not in part_names, "The key 'return' is reserved"
-  for part in data.parts:
-    part_name = part.id
-    part_data = part.data
-    kwargs[part_name] = process_part(part_data)
-  args = [kwargs.pop(f"_arg_{i}") for i in range(len(kwargs)) if f"_arg_{i}" in kwargs]
-  return args, kwargs
-
-
-class Output:
-
-  def __init__(self, *args, **kwargs: Any):
-
-    if not kwargs:
-      raise ValueError("Output must have at least one  key-value pair")
-    if isinstance(kwargs, dict):
-      kwargs = kwargs
-    else:
-      raise ValueError("Output must be a dictionary")
-    self.parts = kwargs
-    self.args = args
-
-  def __repr__(self):
-    args_str = ', '.join(repr(arg) for arg in self.args)
-    kwargs_str = ', '.join(f"{k}={v!r}" for k, v in self.parts.items())
-    parts = []
-    if args_str:
-      parts.append(args_str)
-    if kwargs_str:
-      parts.append(kwargs_str)
-    return f"Output({', '.join(parts)})"
-
-  def to_proto(self) -> resources_pb2.Output:
-    """Converts the Output instance to a Clarifai protobuf Output message."""
-    data_proto = kwargs_to_proto(*self.args, **self.parts)
-
-    return resources_pb2.Output(
-        data=data_proto, status=status_pb2.Status(code=status_code_pb2.SUCCESS))
-
-
-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
-
-  @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:
-    return PILImage.open(io.BytesIO(self.proto.base64))
-
-  def to_numpy(self) -> np.ndarray:
-    # below is very slow, need to find a better way
-    # return np.array(self.to_pil())
-    pass
-
-  def to_proto(self) -> ImageProto:
-    return self.proto
-
-
-class Audio:
-
-  def __init__(self, proto_audio: AudioProto):
-    self.proto = proto_audio
-
-  @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"Audio({', '.join(attrs)})"
-
-  def to_proto(self) -> AudioProto:
-    return self.proto
-
-
-class Video:
-
-  def __init__(self, proto_video: VideoProto):
-    self.proto = proto_video
-
-  @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"Video({', '.join(attrs)})"
-
-  def to_proto(self) -> VideoProto:
-    return self.proto

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.
-
-'''

clarifai/runners/utils/openai_format.py

@@ -1,87 +0,0 @@
-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,
-            }
-        ],
-    }