clarifai 11.6.4__py3-none-any.whl → 11.6.4rc2__py3-none-any.whl

clarifai/runners/utils/code_script.py

@@ -44,62 +44,66 @@ def generate_client_script(
             model_id,
         )
 
-        _CLIENT_TEMPLATE = """
+        _CLIENT_TEMPLATE = f"""
 import asyncio
 import os
+
 from fastmcp import Client
 from fastmcp.client.transports import StreamableHttpTransport
 
-transport = StreamableHttpTransport(url="%s",
-                                    headers={"Authorization": "Bearer " + os.environ["CLARIFAI_PAT"]})
+transport = StreamableHttpTransport(
+    url="{mcp_url}",
+    headers={{"Authorization": "Bearer " + os.environ["CLARIFAI_PAT"]}},
+)
 
 async def main():
-  async with Client(transport) as client:
-    tools = await client.list_tools()
-    print(f"Available tools: {tools}")
-    # TODO: update the dictionary of arguments passed to call_tool to make sense for your MCP.
-    result = await client.call_tool(tools[0].name, {"a": 5, "b": 3})
-    print(f"Result: {result[0].text}")
+    async with Client(transport) as client:
+        tools = await client.list_tools()
+        print(f"Available tools: {{tools}}")
+        # TODO: update the dictionary of arguments passed to call_tool to make sense for your MCP.
+        result = await client.call_tool(tools[0].name, {{"a": 5, "b": 3}})
+        print(f"Result: {{result[0].text}}")
 
 if __name__ == "__main__":
-  asyncio.run(main())
+    asyncio.run(main())
 """
-        return _CLIENT_TEMPLATE % mcp_url
+        return _CLIENT_TEMPLATE
 
     if has_signature_method(OPENAI_TRANSPORT_NAME, method_signatures):
         openai_api_base = url_helper.openai_api_url()
         model_ui_url = url_helper.clarifai_url(user_id, app_id, "models", model_id)
-        _CLIENT_TEMPLATE = """
+        _CLIENT_TEMPLATE = f"""
 import os
+
 from openai import OpenAI
 
 client = OpenAI(
-    base_url="%s",
+    base_url="{openai_api_base}",
     api_key=os.environ['CLARIFAI_PAT'],
 )
+
 response = client.chat.completions.create(
-    model="%s",
+    model="{model_ui_url}",
     messages=[
-        {"role": "system", "content": "Talk like a pirate."},
-        {
+        {{"role": "system", "content": "Talk like a pirate."}},
+        {{
             "role": "user",
             "content": "How do I check if a Python object is an instance of a class?",
-        },
+        }},
     ],
     temperature=0.7,
-    stream=False, # stream=True also works, just iterator over the response
+    stream=False,  # stream=True also works, just iterator over the response
 )
 print(response)
 """
-        return _CLIENT_TEMPLATE % (openai_api_base, model_ui_url)
-
-    _CLIENT_TEMPLATE = """\
-import os
-
-from clarifai.client import Model
-from clarifai.runners.utils import data_types
-{model_section}
-    """
+        return _CLIENT_TEMPLATE
+    # Generate client template
+    _CLIENT_TEMPLATE = (
+        "import os\n\n"
+        "from clarifai.client import Model\n"
+        "from clarifai.runners.utils import data_types\n\n"
+        "{model_section}\n"
+    )
     if deployment_id and (compute_cluster_id or nodepool_id):
         raise ValueError(
             "You can only specify one of deployment_id or compute_cluster_id and nodepool_id."
@@ -108,26 +112,26 @@ from clarifai.runners.utils import data_types
         deployment_id = None
     else:
         deployment_id = (
-            "os.environ['CLARIFAI_DEPLOYMENT_ID']" if not deployment_id else repr(deployment_id)
+            'os.environ["CLARIFAI_DEPLOYMENT_ID"]' if not deployment_id else repr(deployment_id)
         )
 
     deployment_line = (
-        f'deployment_id = {deployment_id}, # Only needed for dedicated deployed models'
+        f'deployment_id={deployment_id},  # Only needed for dedicated deployed models'
         if deployment_id
         else ""
     )
     compute_cluster_line = (
-        f'compute_cluster_id = "{compute_cluster_id}",' if compute_cluster_id else ""
+        f'compute_cluster_id="{compute_cluster_id}",' if compute_cluster_id else ""
     )
     nodepool_line = (
-        f'nodepool_id = "{nodepool_id}", # Only needed for dedicated nodepool'
+        f'nodepool_id="{nodepool_id}",  # Only needed for dedicated nodepool'
         if nodepool_id
         else ""
     )
 
     base_url_str = ""
     if base_url is not None:
-        base_url_str = f"base_url='{base_url}',"
+        base_url_str = f'base_url="{base_url}",'
 
     # Join all non-empty lines
     optional_lines = "\n    ".join(
@@ -138,19 +142,17 @@ from clarifai.runners.utils import data_types
 
     if use_ctx:
         model_section = """
-model = Model.from_current_context()"""
+model = Model.from_current_context()
+"""
     else:
         model_ui_url = url_helper.clarifai_url(user_id, app_id, "models", model_id)
-        model_section = f"""
-model = Model("{model_ui_url}",
-    {optional_lines}
- )
-"""
+        if optional_lines:
+            model_args = f'"{model_ui_url}",\n    {optional_lines}'
+        else:
+            model_args = f'"{model_ui_url}"'
+        model_section = f"model = Model(\n    {model_args}\n)"
 
-    # Generate client template
-    client_template = _CLIENT_TEMPLATE.format(
-        model_section=model_section,
-    )
+    client_template = _CLIENT_TEMPLATE.format(model_section=model_section.strip("\n"))
 
     # Generate method signatures
     method_signatures_str = []
@@ -158,8 +160,9 @@ model = Model("{model_ui_url}",
         if method_signature is None:
             continue
         method_name = method_signature.name
-        client_script_str = f'response = model.{method_name}('
+        client_script_str = f"response = model.{method_name}("
         annotations = _get_annotations_source(method_signature)
+        param_lines = []
         for idx, (param_name, (param_type, default_value, required)) in enumerate(
             annotations.items()
         ):
@@ -172,8 +175,11 @@ model = Model("{model_ui_url}",
             if param_type == "str" and default_value is not None:
                 default_value = json.dumps(default_value)
             if default_value is not None:
-                client_script_str += f"{param_name}={default_value}, "
-        client_script_str = client_script_str.rstrip(", ") + ")"
+                param_lines.append(f"    {param_name}={default_value},")
+        if param_lines:
+            client_script_str += "\n" + "\n".join(param_lines) + "\n)"
+        else:
+            client_script_str += ")"
         if method_signature.method_type == resources_pb2.RunnerMethodType.UNARY_UNARY:
             client_script_str += "\nprint(response)"
         elif method_signature.method_type == resources_pb2.RunnerMethodType.UNARY_STREAMING:
@@ -191,7 +197,7 @@ model = Model("{model_ui_url}",
         )
     script_lines.append("# Example usage:")
     script_lines.append(client_template)
-    script_lines.append("# Example model prediction from different model methods: \n")
+    script_lines.append("# Example model prediction from different model methods:\n")
     script_lines.append(method_signatures_str)
     script_lines.append("")
     script = "\n".join(script_lines)

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)