clarifai 11.4.1__py3-none-any.whl → 11.4.3__py3-none-any.whl

clarifai/runners/utils/code_script.py

@@ -3,7 +3,8 @@ from typing import List
 
 from clarifai_grpc.grpc.api import resources_pb2
 
-from clarifai.runners.utils import data_types
+from clarifai.runners.utils import data_utils
+from clarifai.urls.helper import ClarifaiUrlHelper
 
 
 def generate_client_script(
@@ -15,6 +16,38 @@ def generate_client_script(
     deployment_id: str = None,
     use_ctx: bool = False,
 ) -> str:
+    url_helper = ClarifaiUrlHelper()
+
+    # Provide an mcp client config
+    if len(method_signatures) == 1 and method_signatures[0].name == "mcp_transport":
+        api_url = url_helper.api_url(
+            user_id,
+            app_id,
+            "models",
+            model_id,
+        )
+
+        _CLIENT_TEMPLATE = """
+import asyncio
+import os
+from fastmcp import Client
+from fastmcp.client.transports import StreamableHttpTransport
+
+transport = StreamableHttpTransport(url="%s/mcp",
+                                    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}")
+    result = await client.call_tool(tools[0].name, {"a": 5, "b": 3})
+    print(f"Result: {result[0].text}")
+
+if __name__ == "__main__":
+  asyncio.run(main())
+"""
+        return _CLIENT_TEMPLATE % api_url
+
     _CLIENT_TEMPLATE = """\
 import os
 
@@ -35,19 +68,13 @@ from clarifai.runners.utils import data_types
         model_section = """
 model = Model.from_current_context()"""
     else:
-        model_section = """
- model = Model("https://clarifai.com/{user_id}/{app_id}/{model_id}",
+        model_ui_url = url_helper.clarifai_url(user_id, app_id, "models", model_id)
+        model_section = f"""
+model = Model({model_ui_url},
                deployment_id = {deployment_id}, # Only needed for dedicated deployed models
                {base_url_str}
  )
 """
-        model_section = _CLIENT_TEMPLATE.format(
-            user_id=user_id,
-            app_id=app_id,
-            model_id=model_id,
-            deployment_id=deployment_id,
-            base_url_str=base_url_str,
-        )
 
     # Generate client template
     client_template = _CLIENT_TEMPLATE.format(
@@ -58,28 +85,24 @@ model = Model.from_current_context()"""
     method_signatures_str = []
     for method_signature in method_signatures:
         method_name = method_signature.name
-        if method_signature.method_type in [
-            resources_pb2.RunnerMethodType.UNARY_UNARY,
-            resources_pb2.RunnerMethodType.UNARY_STREAMING,
-        ]:
-            client_script_str = f'response = model.{method_name}('
-            annotations = _get_annotations_source(method_signature)
-            for param_name, (param_type, default_value) in annotations.items():
-                if param_name == "return":
-                    continue
-                if default_value is None:
-                    default_value = _set_default_value(param_type)
-                    if param_type == "str":
-                        default_value = repr(default_value)
-
-                client_script_str += f"{param_name}={default_value}, "
-            client_script_str = client_script_str.rstrip(", ") + ")"
-            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:
-                client_script_str += "\nfor res in response:\n    print(res)"
-            client_script_str += "\n"
-            method_signatures_str.append(client_script_str)
+        client_script_str = f'response = model.{method_name}('
+        annotations = _get_annotations_source(method_signature)
+        for param_name, (param_type, default_value) in annotations.items():
+            print(
+                f"param_name: {param_name}, param_type: {param_type}, default_value: {default_value}"
+            )
+            if param_name == "return":
+                continue
+            if default_value is None:
+                default_value = _set_default_value(param_type)
+            client_script_str += f"{param_name}={default_value}, "
+        client_script_str = client_script_str.rstrip(", ") + ")"
+        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:
+            client_script_str += "\nfor res in response:\n    print(res)"
+        client_script_str += "\n"
+        method_signatures_str.append(client_script_str)
 
     method_signatures_str = "\n".join(method_signatures_str)
     # Combine all parts
@@ -107,9 +130,8 @@ def _get_annotations_source(method_signature: resources_pb2.MethodSignature) ->
         if input_field.iterator:
             param_type = f"Iterator[{param_type}]"
         default_value = None
-        if input_field.default:
+        if data_utils.Param.get_default(input_field):
             default_value = _parse_default_value(input_field)
-
         annotations[param_name] = (param_type, default_value)
     if not method_signature.output_fields:
         raise ValueError("MethodSignature must have at least one output field")
@@ -177,23 +199,21 @@ def _map_default_value(field_type):
     elif field_type == "bool":
         default_value = False
     elif field_type == "data_types.Image":
-        default_value = data_types.Image.from_url("https://samples.clarifai.com/metro-north.jpg")
+        default_value = 'data_types.Image.from_url("https://samples.clarifai.com/metro-north.jpg")'
     elif field_type == "data_types.Text":
-        default_value = data_types.Text("What's the future of AI?")
+        default_value = 'data_types.Text("What is the future of AI?")'
     elif field_type == "data_types.Audio":
-        default_value = data_types.Audio.from_url("https://samples.clarifai.com/audio.mp3")
+        default_value = 'data_types.Audio.from_url("https://samples.clarifai.com/audio.mp3")'
     elif field_type == "data_types.Video":
-        default_value = data_types.Video.from_url("https://samples.clarifai.com/video.mp4")
+        default_value = 'data_types.Video.from_url("https://samples.clarifai.com/video.mp4")'
     elif field_type == "data_types.Concept":
-        default_value = data_types.Concept(id="concept_id", name="dog", value=0.95)
+        default_value = 'data_types.Concept(id="concept_id", name="dog", value=0.95)'
     elif field_type == "data_types.Region":
-        default_value = data_types.Region(
-            box=[0.1, 0.1, 0.5, 0.5],
-        )
+        default_value = 'data_types.Region(box=[0.1, 0.1, 0.5, 0.5],)'
     elif field_type == "data_types.Frame":
-        default_value = data_types.Frame.from_url("https://samples.clarifai.com/video.mp4", 0)
+        default_value = 'data_types.Frame.from_url("https://samples.clarifai.com/video.mp4", 0)'
     elif field_type == "data_types.NDArray":
-        default_value = data_types.NDArray([1, 2, 3])
+        default_value = 'data_types.NDArray([1, 2, 3])'
     else:
         default_value = None
     return default_value
@@ -203,6 +223,12 @@ def _set_default_value(field_type):
     """
     Set the default value of a field if it is not set.
     """
+    is_iterator = False
+    print(f"before field_type: {field_type}")
+    if field_type.startswith("Iterator["):
+        is_iterator = True
+        field_type = field_type[9:-1]
+    print(f"after field_type: {field_type}")
     default_value = None
     default_value = _map_default_value(field_type)
     if field_type.startswith("List["):
@@ -219,6 +245,11 @@ def _set_default_value(field_type):
         element_type_defaults = [_map_default_value(et) for et in element_types]
         default_value = f"{{{', '.join([str(et) for et in element_type_defaults])}}}"
 
+    if field_type == 'str':
+        default_value = repr(default_value)
+    if is_iterator:
+        default_value = f'iter([{default_value}])'
+    print(f"after default_value: {default_value}")
     return default_value
 
 

clarifai/runners/utils/const.py

@@ -4,14 +4,28 @@ registry = os.environ.get('CLARIFAI_BASE_IMAGE_REGISTRY', 'public.ecr.aws/clarif
 
 GIT_SHA = "b8ae56bf3b7c95e686ca002b07ca83d259c716eb"
 
+AMD_GIT_SHA = "81e942130173f54927e7c9a65aabc7e32780616d"
+
 PYTHON_BASE_IMAGE = registry + '/python-base:{python_version}-' + GIT_SHA
 TORCH_BASE_IMAGE = registry + '/torch:{torch_version}-py{python_version}-{gpu_version}-' + GIT_SHA
 
+AMD_PYTHON_BASE_IMAGE = registry + '/amd-python-base:{python_version}-' + AMD_GIT_SHA
+AMD_TORCH_BASE_IMAGE = (
+    registry + '/amd-torch:{torch_version}-py{python_version}-{gpu_version}-' + AMD_GIT_SHA
+)
+AMD_VLLM_BASE_IMAGE = (
+    registry + '/amd-vllm:{torch_version}-py{python_version}-{gpu_version}-' + AMD_GIT_SHA
+)
+
 # List of available python base images
 AVAILABLE_PYTHON_IMAGES = ['3.11', '3.12']
 
 DEFAULT_PYTHON_VERSION = 3.12
 
+DEFAULT_AMD_TORCH_VERSION = '2.8.0.dev20250511+rocm6.4'
+
+DEFAULT_AMD_GPU_VERSION = 'rocm6.4'
+
 # By default we download at runtime.
 DEFAULT_DOWNLOAD_CHECKPOINT_WHEN = "runtime"
 
@@ -29,6 +43,7 @@ AVAILABLE_TORCH_IMAGES = [
     '2.7.0-py3.12-cu128',
     '2.7.0-py3.12-rocm6.3',
 ]
+
 CONCEPTS_REQUIRED_MODEL_TYPE = [
     'visual-classifier',
     'visual-detector',

clarifai/runners/utils/data_types/data_types.py

@@ -395,6 +395,22 @@ class Image(MessageData):
             raise ValueError("Image has no bytes")
         return PILImage.open(io.BytesIO(self.proto.base64))
 
+    def to_base64_str(self) -> str:
+        if not self.proto.base64:
+            raise ValueError("Image has no bytes")
+        if isinstance(self.proto.base64, str):
+            return self.proto.base64
+        if isinstance(self.proto.base64, bytes):
+            try:
+                # trying direct decode (if already a base64 bytes)
+                return self.proto.base64.decode('utf-8')
+            except UnicodeDecodeError:
+                import base64
+
+                return base64.b64encode(self.proto.base64).decode('utf-8')
+        else:
+            raise TypeError("Expected str or bytes for Image.base64")
+
     def to_numpy(self) -> np.ndarray:
         return np.asarray(self.to_pil())
 
@@ -466,6 +482,22 @@ class Audio(MessageData):
     def to_proto(self) -> AudioProto:
         return self.proto
 
+    def to_base64_str(self) -> str:
+        if not self.proto.base64:
+            raise ValueError("Audio has no bytes")
+        if isinstance(self.proto.base64, str):
+            return self.proto.base64
+        if isinstance(self.proto.base64, bytes):
+            try:
+                # trying direct decode (if already a base64 bytes)
+                return self.proto.base64.decode('utf-8')
+            except UnicodeDecodeError:
+                import base64
+
+                return base64.b64encode(self.proto.base64).decode('utf-8')
+        else:
+            raise TypeError("Expected str or bytes for Audio.base64")
+
     @classmethod
     def from_proto(cls, proto: AudioProto) -> "Audio":
         return cls(proto)
@@ -578,6 +610,22 @@ class Video(MessageData):
     def to_proto(self) -> VideoProto:
         return self.proto
 
+    def to_base64_str(self) -> str:
+        if not self.proto.base64:
+            raise ValueError("Video has no bytes")
+        if isinstance(self.proto.base64, str):
+            return self.proto.base64
+        if isinstance(self.proto.base64, bytes):
+            try:
+                # trying direct decode (if already a base64 bytes)
+                return self.proto.base64.decode('utf-8')
+            except UnicodeDecodeError:
+                import base64
+
+                return base64.b64encode(self.proto.base64).decode('utf-8')
+        else:
+            raise TypeError("Expected str or bytes for Video.base64")
+
     @classmethod
     def from_proto(cls, proto: VideoProto) -> "Video":
         return cls(proto)

clarifai/runners/utils/data_utils.py

@@ -1,62 +1,89 @@
+import base64
+import json
 import math
 import operator
 from io import BytesIO
-from typing import List
+from typing import Dict, List
 
+import requests
 from clarifai_grpc.grpc.api import resources_pb2
 from clarifai_grpc.grpc.api.resources_pb2 import ModelTypeEnumOption, ModelTypeRangeInfo
 from clarifai_grpc.grpc.api.resources_pb2 import ModelTypeField as ParamProto
-from PIL import Image
+from PIL import Image as PILImage
 
-from clarifai.runners.utils.data_types import MessageData
+from clarifai.runners.utils.data_types import Audio, Image, MessageData, Video
 
 
-def image_to_bytes(img: Image.Image, format="JPEG") -> bytes:
+def image_to_bytes(img: PILImage.Image, format="JPEG") -> bytes:
     buffered = BytesIO()
     img.save(buffered, format=format)
     img_str = buffered.getvalue()
     return img_str
 
 
-def bytes_to_image(bytes_img) -> Image.Image:
-    img = Image.open(BytesIO(bytes_img))
+def bytes_to_image(bytes_img) -> PILImage.Image:
+    img = PILImage.open(BytesIO(bytes_img))
     return img
 
 
-def is_openai_chat_format(messages):
-    """
-    Verify if the given argument follows the OpenAI chat messages format.
-
-    Args:
-        messages (list): A list of dictionaries representing chat messages.
-
-    Returns:
-        bool: True if valid, False otherwise.
-    """
-    if not isinstance(messages, list):
-        return False
-
-    valid_roles = {"system", "user", "assistant", "function"}
-
-    for msg in messages:
-        if not isinstance(msg, dict):
-            return False
-        if "role" not in msg or "content" not in msg:
-            return False
-        if msg["role"] not in valid_roles:
-            return False
-
-        content = msg["content"]
-
-        # Content should be either a string (text message) or a multimodal list
-        if isinstance(content, str):
-            continue  # Valid text message
-
-        elif isinstance(content, list):
-            for item in content:
-                if not isinstance(item, dict):
-                    return False
-    return True
+def process_image(image: Image) -> Dict:
+    """Convert Clarifai Image object to OpenAI image format."""
+
+    if image.bytes:
+        b64_img = image.to_base64_str()
+        return {'type': 'image_url', 'image_url': {'url': f"data:image/jpeg;base64,{b64_img}"}}
+    elif image.url:
+        return {'type': 'image_url', 'image_url': {'url': image.url}}
+    else:
+        raise ValueError("Image must contain either bytes or URL")
+
+
+def process_audio(audio: Audio) -> Dict:
+    """Convert Clarifai Audio object to OpenAI audio format."""
+
+    if audio.bytes:
+        audio = audio.to_base64_str()
+        audio = {
+            "type": "input_audio",
+            "input_audio": {"data": audio, "format": "wav"},
+        }
+    elif audio.url:
+        response = requests.get(audio.url)
+        if response.status_code != 200:
+            raise ValueError(f"Failed to fetch audio from URL: {audio.url}")
+        audio_base64_str = base64.b64encode(response.content).decode('utf-8')
+        audio = {
+            "type": "input_audio",
+            "input_audio": {"data": audio_base64_str, "format": "wav"},
+        }
+    else:
+        raise ValueError("Audio must contain either bytes or URL")
+
+    return audio
+
+
+def process_video(video: Video) -> Dict:
+    """Convert Clarifai Video object to OpenAI video format."""
+
+    if video.bytes:
+        video = "data:video/mp4;base64," + video.to_base64_str()
+        video = {
+            "type": "video_url",
+            "video_url": {"url": video},
+        }
+    elif video.url:
+        response = requests.get(video.url)
+        if response.status_code != 200:
+            raise ValueError(f"Failed to fetch video from URL: {video.url}")
+        video_base64_str = base64.b64encode(response.content).decode('utf-8')
+        video = {
+            "type": "video_url",
+            "video_url": {"url": video_base64_str},
+        }
+    else:
+        raise ValueError("Video must contain either bytes or URL")
+
+    return video
 
 
 class Param(MessageData):
@@ -64,7 +91,7 @@ class Param(MessageData):
 
     def __init__(
         self,
-        default=None,
+        default,
         description=None,
         min_value=None,
         max_value=None,
@@ -77,6 +104,7 @@ class Param(MessageData):
         self.max_value = max_value
         self.choices = choices
         self.is_param = is_param
+        self._patch_encoder()
 
     def __repr__(self) -> str:
         attrs = []
@@ -153,6 +181,16 @@ class Param(MessageData):
     def __ge__(self, other):
         return self.default >= other
 
+    def __getattribute__(self, name):
+        """Intercept attribute access to mimic default value behavior"""
+        try:
+            # First try to get Param attributes normally
+            return object.__getattribute__(self, name)
+        except AttributeError:
+            # Fall back to the default value's attributes
+            default = object.__getattribute__(self, 'default')
+            return getattr(default, name)
+
     # Arithmetic operators – # arithmetic & bitwise operators – auto-generated
     _arith_ops = {
         "__add__": operator.add,
@@ -169,7 +207,6 @@ class Param(MessageData):
         "__rshift__": operator.rshift,
     }
 
-    # Create both left- and right-hand versions of each operator
     for _name, _op in _arith_ops.items():
 
         def _make(op):
@@ -243,6 +280,24 @@ class Param(MessageData):
             return self
         return self.default
 
+    def __json__(self):
+        return self.default if not hasattr(self.default, '__json__') else self.default.__json__()
+
+    @classmethod
+    def _patch_encoder(cls):
+        # only patch once
+        if getattr(json.JSONEncoder, "_user_patched", False):
+            return
+        original = json.JSONEncoder.default
+
+        def default(self, obj):
+            if isinstance(obj, Param):
+                return obj.__json__()
+            return original(self, obj)
+
+        json.JSONEncoder.default = default
+        json.JSONEncoder._user_patched = True
+
     def to_proto(self, proto=None) -> ParamProto:
         if proto is None:
             proto = ParamProto()
@@ -254,7 +309,7 @@ class Param(MessageData):
                 option = ModelTypeEnumOption(id=str(choice))
                 proto.model_type_enum_options.append(option)
 
-        proto.required = self.default is None
+        proto.required = False
 
         if self.min_value is not None or self.max_value is not None:
             range_info = ModelTypeRangeInfo()
@@ -324,8 +379,7 @@ class Param(MessageData):
 
             if proto is None:
                 proto = ParamProto()
-            if default is not None:
-                proto.default = json.dumps(default)
+            proto.default = json.dumps(default)
             return proto
         except Exception:
             if default is not None:

clarifai/runners/utils/loader.py

@@ -41,7 +41,7 @@ class HuggingFaceLoader:
             return True
         except Exception as e:
             logger.error(
-                f"Error setting up Hugging Face token, please make sure you have the correct token: {e}"
+                f"Invalid Hugging Face token provided in the config file, this might cause issues with downloading the restricted model checkpoints. Failed reason: {e}"
             )
             return False
 
@@ -63,7 +63,6 @@ class HuggingFaceLoader:
             try:
                 is_hf_model_exists = self.validate_hf_model()
                 if not is_hf_model_exists:
-                    logger.error("Model %s not found on Hugging Face" % (self.repo_id))
                     return False
 
                 self.ignore_patterns = self._get_ignore_patterns()
@@ -205,6 +204,28 @@ class HuggingFaceLoader:
             ]
         return self.ignore_patterns
 
+    @classmethod
+    def validate_hf_repo_access(cls, repo_id: str, token: str = None) -> bool:
+        # check if model exists on HF
+        try:
+            from huggingface_hub import auth_check
+            from huggingface_hub.utils import GatedRepoError, RepositoryNotFoundError
+        except ImportError:
+            raise ImportError(cls.HF_DOWNLOAD_TEXT)
+
+        try:
+            auth_check(repo_id, token=token)
+            logger.info("Hugging Face repo access validated")
+            return True
+        except GatedRepoError:
+            logger.error(
+                "Hugging Face repo is gated. Please make sure you have access to the repo."
+            )
+            return False
+        except RepositoryNotFoundError:
+            logger.error("Hugging Face repo not found. Please make sure the repo exists.")
+            return False
+
     @staticmethod
     def validate_config(checkpoint_path: str):
         # check if downloaded config.json exists

clarifai/runners/utils/method_signatures.py

@@ -302,6 +302,9 @@ def serialize(kwargs, signatures, proto=None, is_output=False):
                 raise TypeError(f'Missing required argument: {sig.name}')
             continue  # skip missing fields, they can be set to default on the server
         data = kwargs[sig.name]
+        default = data_utils.Param.get_default(sig)
+        if data is None and default is None:
+            continue
         serializer = serializer_from_signature(sig)
         # TODO determine if any (esp the first) var can go in the proto without parts
         # and whether to put this in the signature or dynamically determine it
@@ -312,7 +315,7 @@ def serialize(kwargs, signatures, proto=None, is_output=False):
     return proto
 
 
-def deserialize(proto, signatures, inference_params={}, is_output=False):
+def deserialize(proto, signatures, is_output=False):
     '''
     Deserialize the given proto into kwargs using the given signatures.
     '''
@@ -323,11 +326,8 @@ def deserialize(proto, signatures, inference_params={}, is_output=False):
     for sig_i, sig in enumerate(signatures):
         serializer = serializer_from_signature(sig)
         part = parts_by_name.get(sig.name)
-        inference_params_value = inference_params.get(sig.name)
         if part is not None:
             kwargs[sig.name] = serializer.deserialize(part.data)
-        elif inference_params_value is not None:
-            kwargs[sig.name] = inference_params_value
         else:
             if sig_i == 0:
                 # possible inlined first value