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

clarifai/runners/models/model_run_locally.py

@@ -442,10 +442,6 @@ def main(
     manager = ModelRunLocally(model_path)
     # get whatever stage is in config.yaml to force download now
     # also always write to where upload/build wants to, not the /tmp folder that runtime stage uses
-    _, _, _, when, _, _ = manager.builder._validate_config_checkpoints()
-    manager.builder.download_checkpoints(
-        stage=when, checkpoint_path_override=manager.builder.checkpoint_path
-    )
     if inside_container:
         if not manager.is_docker_installed():
             sys.exit(1)

clarifai/runners/models/test_model_builder.py

@@ -0,0 +1,89 @@
+import unittest
+from unittest.mock import patch, mock_open
+from clarifai.runners.models.model_builder import (
+    ModelBuilder,
+    DEFAULT_DOWNLOAD_CHECKPOINT_WHEN,
+)
+
+mock_data = """
+checkpoints:
+  type: huggingface
+  repo_id: test_repo
+model:
+  user_id: test_user
+  app_id: test_app
+  id: test_model
+  model_type_id: test_type
+inference_compute_info:
+  cpu_limit: "2"
+  cpu_memory: "4Gi"
+  num_accelerators: 0
+"""
+
+
+class TestModelBuilder(unittest.TestCase):
+    @patch("builtins.open", new_callable=mock_open, read_data=mock_data)
+    @patch("os.path.exists")
+    @patch("os.listdir")
+    def test_validate_folder(self, mock_listdir, mock_exists, mock_open_file):
+        mock_exists.return_value = True
+        mock_listdir.return_value = ["config.yaml", "1", "requirements.txt"]
+
+        builder = ModelBuilder(folder="test_folder", validate_api_ids=False)
+        validated_folder = builder._validate_folder("test_folder")
+        self.assertIn("test_folder", validated_folder)
+
+    def test_default_download_checkpoint_when(self):
+        self.assertEqual(DEFAULT_DOWNLOAD_CHECKPOINT_WHEN, "runtime")
+
+    @patch(
+        "builtins.open",
+        new_callable=mock_open,
+        read_data="checkpoints:\n  type: huggingface\n  repo_id: test_repo\n",
+    )
+    @patch("os.path.exists")
+    @patch("yaml.safe_load")
+    def test_load_config(self, mock_yaml_load, mock_exists, mock_open_file):
+        mock_exists.return_value = True
+        mock_yaml_load.return_value = {
+            "checkpoints": {"type": "huggingface", "repo_id": "test_repo"}
+        }
+        config = ModelBuilder._load_config("config.yaml")
+        self.assertIn("checkpoints", config)
+        self.assertEqual(config["checkpoints"]["type"], "huggingface")
+
+    @patch("shutil.copy")
+    @patch("os.path.exists")
+    def test_backup_config(self, mock_exists, mock_copy):
+        mock_exists.side_effect = [True, False]  # config exists, backup does not
+        ModelBuilder._backup_config("config.yaml")
+        mock_copy.assert_called_once_with("config.yaml", "config.yaml.bak")
+
+    @patch("builtins.open", new_callable=mock_open)
+    @patch("yaml.safe_dump")
+    def test_save_config(self, mock_yaml_dump, mock_open_file):
+        config = {"key": "value"}
+        ModelBuilder._save_config("config.yaml", config)
+        mock_yaml_dump.assert_called_once_with(config, mock_open_file())
+
+    def test_validate_config_model(self):
+        builder = ModelBuilder(folder="test_folder", validate_api_ids=False)
+        builder.config = {"model": {}}
+        try:
+            builder._validate_config_model()
+        except AssertionError:
+            self.fail("_validate_config_model raised AssertionError unexpectedly!")
+
+    @patch("os.path.exists")
+    @patch("os.listdir")
+    def test_validate_folder_missing_config(self, mock_listdir, mock_exists):
+        mock_exists.return_value = True
+        mock_listdir.return_value = ["1", "requirements.txt"]
+
+        builder = ModelBuilder(folder="test_folder", validate_api_ids=False)
+        with self.assertRaises(AssertionError):
+            builder._validate_folder("test_folder")
+
+
+if __name__ == "__main__":
+    unittest.main()

clarifai/runners/models/visual_classifier_class.py

@@ -0,0 +1,75 @@
+import os
+import tempfile
+from io import BytesIO
+from typing import Dict, Iterator, List
+
+import cv2
+import torch
+from PIL import Image as PILImage
+
+from clarifai.runners.models.model_class import ModelClass
+from clarifai.runners.utils.data_types import Concept, Frame, Image
+from clarifai.utils.logging import logger
+
+
+class VisualClassifierClass(ModelClass):
+    """Base class for visual classification models supporting image and video processing."""
+
+    @staticmethod
+    def preprocess_image(image_bytes: bytes) -> PILImage:
+        """Convert image bytes to PIL Image."""
+        return PILImage.open(BytesIO(image_bytes)).convert("RGB")
+
+    @staticmethod
+    def video_to_frames(video_bytes: bytes) -> Iterator[Frame]:
+        """Convert video bytes to frames.
+
+        Args:
+            video_bytes: Raw video data in bytes
+
+        Yields:
+            Frame with JPEG encoded frame data as bytes and timestamp in milliseconds
+        """
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as temp_video_file:
+            temp_video_file.write(video_bytes)
+            temp_video_path = temp_video_file.name
+            logger.debug(f"temp_video_path: {temp_video_path}")
+
+            video = cv2.VideoCapture(temp_video_path)
+            logger.debug(f"video opened: {video.isOpened()}")
+
+            while video.isOpened():
+                ret, frame = video.read()
+                if not ret:
+                    break
+                # Get frame timestamp in milliseconds
+                timestamp_ms = video.get(cv2.CAP_PROP_POS_MSEC)
+                frame_bytes = cv2.imencode('.jpg', frame)[1].tobytes()
+                yield Frame(image=Image(bytes=frame_bytes), time=timestamp_ms)
+
+            video.release()
+            os.unlink(temp_video_path)
+
+    @staticmethod
+    def process_concepts(
+        logits: torch.Tensor, threshold: float, model_labels: Dict[int, str]
+    ) -> List[List[Concept]]:
+        """Convert model logits into a structured format of concepts.
+
+        Args:
+            logits: Model output logits as a tensor (batch_size x num_classes)
+            model_labels: Dictionary mapping label indices to label names
+
+        Returns:
+            List of lists containing Concept objects for each input in the batch
+        """
+        outputs = []
+        for logit in logits:
+            probs = torch.softmax(logit, dim=-1)
+            sorted_indices = torch.argsort(probs, dim=-1, descending=True)
+            output_concepts = []
+            for idx in sorted_indices:
+                concept = Concept(name=model_labels[idx.item()], value=probs[idx].item())
+                output_concepts.append(concept)
+            outputs.append(output_concepts)
+        return outputs

clarifai/runners/models/visual_detector_class.py

@@ -0,0 +1,79 @@
+import os
+import tempfile
+from io import BytesIO
+from typing import Dict, Iterator, List
+
+import cv2
+import torch
+from PIL import Image as PILImage
+
+from clarifai.runners.models.model_class import ModelClass
+from clarifai.runners.utils.data_types import Concept, Frame, Image, Region
+from clarifai.utils.logging import logger
+
+
+class VisualDetectorClass(ModelClass):
+    """Base class for visual detection models supporting image and video processing."""
+
+    @staticmethod
+    def preprocess_image(image_bytes: bytes) -> PILImage:
+        """Convert image bytes to PIL Image."""
+        return PILImage.open(BytesIO(image_bytes)).convert("RGB")
+
+    @staticmethod
+    def video_to_frames(video_bytes: bytes) -> Iterator[Frame]:
+        """Convert video bytes to frames.
+
+        Args:
+            video_bytes: Raw video data in bytes
+
+        Yields:
+            Frame with JPEG encoded frame data as bytes and timestamp in milliseconds
+        """
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as temp_video_file:
+            temp_video_file.write(video_bytes)
+            temp_video_path = temp_video_file.name
+            logger.debug(f"temp_video_path: {temp_video_path}")
+
+            video = cv2.VideoCapture(temp_video_path)
+            logger.debug(f"video opened: {video.isOpened()}")
+
+            while video.isOpened():
+                ret, frame = video.read()
+                if not ret:
+                    break
+                # Get frame timestamp in milliseconds
+                timestamp_ms = video.get(cv2.CAP_PROP_POS_MSEC)
+                frame_bytes = cv2.imencode('.jpg', frame)[1].tobytes()
+                yield Frame(image=Image(bytes=frame_bytes), time=timestamp_ms)
+
+            video.release()
+            os.unlink(temp_video_path)
+
+    @staticmethod
+    def process_detections(
+        results: List[Dict[str, torch.Tensor]], threshold: float, model_labels: Dict[int, str]
+    ) -> List[List[Region]]:
+        """Convert model outputs into a structured format of detections.
+
+        Args:
+            results: Raw detection results from model
+            threshold: Confidence threshold for detections
+            model_labels: Dictionary mapping label indices to names
+
+        Returns:
+            List of lists containing Region objects for each detection
+        """
+        outputs = []
+        for result in results:
+            detections = []
+            for score, label_idx, box in zip(result["scores"], result["labels"], result["boxes"]):
+                if score > threshold:
+                    label = model_labels[label_idx.item()]
+                    detections.append(
+                        Region(
+                            box=box.tolist(), concepts=[Concept(name=label, value=score.item())]
+                        )
+                    )
+            outputs.append(detections)
+        return outputs

clarifai/runners/utils/code_script.py

@@ -3,7 +3,7 @@ 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
 
 
 def generate_client_script(
@@ -35,19 +35,12 @@ 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_section = f"""
+model = Model("https://clarifai.com/{user_id}/{app_id}/models/{model_id}",
                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 +51,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 +96,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 +165,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 +189,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 +211,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',