clarifai 11.4.0__py3-none-any.whl → 11.4.2__py3-none-any.whl

clarifai/__init__.py

@@ -1 +1 @@
-__version__ = "11.4.0"
+__version__ = "11.4.2"

clarifai/client/dataset.py

@@ -685,6 +685,12 @@ class Dataset(Lister, BaseClient):
         Note:
             This is a beta feature and is subject to change.
         """
+        try:
+            import rich  # noqa: F401
+        except ImportError:
+            raise UserError(
+                "Rich library is not installed. Please install it using pip install rich>=13.4.2"
+            )
         self.logger.info("Getting dataset upload status...")
         dataset_version_id = uuid.uuid4().hex
         _ = self.create_version(id=dataset_version_id, description="SDK Upload Status")

clarifai/runners/models/model_builder.py

@@ -14,15 +14,17 @@ import yaml
 from clarifai_grpc.grpc.api import resources_pb2, service_pb2
 from clarifai_grpc.grpc.api.status import status_code_pb2
 from google.protobuf import json_format
-from rich import print
-from rich.markup import escape
 
 from clarifai.client.base import BaseClient
 from clarifai.runners.models.model_class import ModelClass
 from clarifai.runners.utils.const import (
+    AMD_PYTHON_BASE_IMAGE,
+    AMD_VLLM_BASE_IMAGE,
     AVAILABLE_PYTHON_IMAGES,
     AVAILABLE_TORCH_IMAGES,
     CONCEPTS_REQUIRED_MODEL_TYPE,
+    DEFAULT_AMD_GPU_VERSION,
+    DEFAULT_AMD_TORCH_VERSION,
     DEFAULT_DOWNLOAD_CHECKPOINT_WHEN,
     DEFAULT_PYTHON_VERSION,
     DEFAULT_RUNTIME_DOWNLOAD_PATH,
@@ -43,13 +45,6 @@ dependencies = [
 ]
 
 
-def _clear_line(n: int = 1) -> None:
-    LINE_UP = '\033[1A'  # Move cursor up one line
-    LINE_CLEAR = '\x1b[2K'  # Clear the entire line
-    for _ in range(n):
-        print(LINE_UP, end=LINE_CLEAR, flush=True)
-
-
 def is_related(object_class, main_class):
     # Check if the object_class is a subclass of main_class
     if issubclass(object_class, main_class):
@@ -361,13 +356,23 @@ class ModelBuilder:
         if self.config.get("checkpoints"):
             loader_type, _, hf_token, _, _, _ = self._validate_config_checkpoints()
 
-            if loader_type == "huggingface" and hf_token:
-                is_valid_token = HuggingFaceLoader.validate_hftoken(hf_token)
-                if not is_valid_token:
+            if loader_type == "huggingface":
+                is_valid_token = hf_token and HuggingFaceLoader.validate_hftoken(hf_token)
+                if not is_valid_token and hf_token:
+                    logger.info(
+                        "Continuing without Hugging Face token for validating config in model builder."
+                    )
+
+                has_repo_access = HuggingFaceLoader.validate_hf_repo_access(
+                    repo_id=self.config.get("checkpoints", {}).get("repo_id"),
+                    token=hf_token if is_valid_token else None,
+                )
+
+                if not has_repo_access:
                     logger.error(
-                        "Invalid Hugging Face token provided in the config file, this might cause issues with downloading the restricted model checkpoints."
+                        f"Invalid Hugging Face repo access for repo {self.config.get('checkpoints').get('repo_id')}. Please check your repo and try again."
                     )
-                    logger.info("Continuing without Hugging Face token")
+                    sys.exit("Token does not have access to HuggingFace repo , exiting.")
 
         num_threads = self.config.get("num_threads")
         if num_threads or num_threads == 0:
@@ -532,6 +537,30 @@ class ModelBuilder:
                 dependencies_version[dependency] = version if version else None
         return dependencies_version
 
+    def _is_amd(self):
+        """
+        Check if the model is AMD or not.
+        """
+        is_amd_gpu = False
+        is_nvidia_gpu = False
+        if "inference_compute_info" in self.config:
+            inference_compute_info = self.config.get('inference_compute_info')
+            if 'accelerator_type' in inference_compute_info:
+                for accelerator in inference_compute_info['accelerator_type']:
+                    if 'amd' in accelerator.lower():
+                        is_amd_gpu = True
+                    elif 'nvidia' in accelerator.lower():
+                        is_nvidia_gpu = True
+        if is_amd_gpu and is_nvidia_gpu:
+            raise Exception(
+                "Both AMD and NVIDIA GPUs are specified in the config file, please use only one type of GPU."
+            )
+        if is_amd_gpu:
+            logger.info("Using AMD base image to build the Docker image and upload the model")
+        elif is_nvidia_gpu:
+            logger.info("Using NVIDIA base image to build the Docker image and upload the model")
+        return is_amd_gpu
+
     def create_dockerfile(self):
         dockerfile_template = os.path.join(
             os.path.dirname(os.path.dirname(__file__)),
@@ -562,30 +591,85 @@ class ModelBuilder:
             )
             python_version = DEFAULT_PYTHON_VERSION
 
-        # This is always the final image used for runtime.
-        final_image = PYTHON_BASE_IMAGE.format(python_version=python_version)
-        downloader_image = PYTHON_BASE_IMAGE.format(python_version=python_version)
-
         # Parse the requirements.txt file to determine the base image
         dependencies = self._parse_requirements()
-        if 'torch' in dependencies and dependencies['torch']:
-            torch_version = dependencies['torch']
-
-            # Sort in reverse so that newer cuda versions come first and are preferred.
-            for image in sorted(AVAILABLE_TORCH_IMAGES, reverse=True):
-                if torch_version in image and f'py{python_version}' in image:
-                    # like cu124, rocm6.3, etc.
-                    gpu_version = image.split('-')[-1]
-                    final_image = TORCH_BASE_IMAGE.format(
-                        torch_version=torch_version,
-                        python_version=python_version,
-                        gpu_version=gpu_version,
+
+        is_amd_gpu = self._is_amd()
+        if is_amd_gpu:
+            final_image = AMD_PYTHON_BASE_IMAGE.format(python_version=python_version)
+            downloader_image = AMD_PYTHON_BASE_IMAGE.format(python_version=python_version)
+            if 'vllm' in dependencies:
+                if python_version != DEFAULT_PYTHON_VERSION:
+                    raise Exception(
+                        f"vLLM is not supported with Python version {python_version}, please use Python version {DEFAULT_PYTHON_VERSION} in your config.yaml"
+                    )
+                torch_version = dependencies.get('torch', None)
+                if 'torch' in dependencies:
+                    if python_version != DEFAULT_PYTHON_VERSION:
+                        raise Exception(
+                            f"torch is not supported with Python version {python_version}, please use Python version {DEFAULT_PYTHON_VERSION} in your config.yaml"
+                        )
+                    if not torch_version:
+                        logger.info(
+                            f"torch version not found in requirements.txt, using the default version {DEFAULT_AMD_TORCH_VERSION}"
+                        )
+                        torch_version = DEFAULT_AMD_TORCH_VERSION
+                    if torch_version not in [DEFAULT_AMD_TORCH_VERSION]:
+                        raise Exception(
+                            f"torch version {torch_version} not supported, please use one of the following versions: {DEFAULT_AMD_TORCH_VERSION} in your requirements.txt"
+                        )
+                python_version = DEFAULT_PYTHON_VERSION
+                gpu_version = DEFAULT_AMD_GPU_VERSION
+                final_image = AMD_VLLM_BASE_IMAGE.format(
+                    torch_version=torch_version,
+                    python_version=python_version,
+                    gpu_version=gpu_version,
+                )
+                logger.info("Using vLLM base image to build the Docker image")
+            elif 'torch' in dependencies:
+                torch_version = dependencies['torch']
+                if python_version != DEFAULT_PYTHON_VERSION:
+                    raise Exception(
+                        f"torch is not supported with Python version {python_version}, please use Python version {DEFAULT_PYTHON_VERSION} in your config.yaml"
                     )
+                if not torch_version:
                     logger.info(
-                        f"Using Torch version {torch_version} base image to build the Docker image"
+                        f"torch version not found in requirements.txt, using the default version {DEFAULT_AMD_TORCH_VERSION}"
                     )
-                    break
-
+                    torch_version = DEFAULT_AMD_TORCH_VERSION
+                if torch_version not in [DEFAULT_AMD_TORCH_VERSION]:
+                    raise Exception(
+                        f"torch version {torch_version} not supported, please use one of the following versions: {DEFAULT_AMD_TORCH_VERSION} in your requirements.txt"
+                    )
+                python_version = DEFAULT_PYTHON_VERSION
+                gpu_version = DEFAULT_AMD_GPU_VERSION
+                final_image = TORCH_BASE_IMAGE.format(
+                    torch_version=torch_version,
+                    python_version=python_version,
+                    gpu_version=gpu_version,
+                )
+                logger.info(
+                    f"Using Torch version {torch_version} base image to build the Docker image"
+                )
+        else:
+            final_image = PYTHON_BASE_IMAGE.format(python_version=python_version)
+            downloader_image = PYTHON_BASE_IMAGE.format(python_version=python_version)
+            if 'torch' in dependencies and dependencies['torch']:
+                torch_version = dependencies['torch']
+                # Sort in reverse so that newer cuda versions come first and are preferred.
+                for image in sorted(AVAILABLE_TORCH_IMAGES, reverse=True):
+                    if torch_version in image and f'py{python_version}' in image:
+                        # like cu124, rocm6.3, etc.
+                        gpu_version = image.split('-')[-1]
+                        final_image = TORCH_BASE_IMAGE.format(
+                            torch_version=torch_version,
+                            python_version=python_version,
+                            gpu_version=gpu_version,
+                        )
+                        logger.info(
+                            f"Using Torch version {torch_version} base image to build the Docker image"
+                        )
+                        break
         if 'clarifai' not in dependencies:
             raise Exception(
                 f"clarifai not found in requirements.txt, please add clarifai to the requirements.txt file with a fixed version. Current version is clarifai=={CLIENT_VERSION}"
@@ -835,7 +919,6 @@ class ModelBuilder:
                 percent_completed = response.status.percent_completed
             details = response.status.details
 
-            _clear_line()
             print(
                 f"Status: {response.status.description}, Progress: {percent_completed}% - {details} ",
                 f"request_id: {response.status.req_id}",
@@ -849,7 +932,23 @@ class ModelBuilder:
         logger.info(f"Created Model Version ID: {self.model_version_id}")
         logger.info(f"Full url to that version is: {self.model_url}")
         try:
-            self.monitor_model_build()
+            is_uploaded = self.monitor_model_build()
+            if is_uploaded:
+                from clarifai.runners.utils import code_script
+
+                method_signatures = self.get_method_signatures()
+                snippet = code_script.generate_client_script(
+                    method_signatures,
+                    user_id=self.client.user_app_id.user_id,
+                    app_id=self.client.user_app_id.app_id,
+                    model_id=self.model_proto.id,
+                )
+                logger.info("""\n
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+# Here is a code snippet to call this model:
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+                """)
+                logger.info(snippet)
         finally:
             if os.path.exists(self.tar_file):
                 logger.debug(f"Cleaning up upload file: {self.tar_file}")
@@ -933,7 +1032,12 @@ class ModelBuilder:
             for log_entry in logs.log_entries:
                 if log_entry.url not in seen_logs:
                     seen_logs.add(log_entry.url)
-                    logger.info(f"{escape(log_entry.message.strip())}")
+                    log_entry_msg = re.sub(
+                        r"(\\*)(\[[a-z#/@][^[]*?])",
+                        lambda m: f"{m.group(1)}{m.group(1)}\\{m.group(2)}",
+                        log_entry.message.strip(),
+                    )
+                    logger.info(log_entry_msg)
             if status_code == status_code_pb2.MODEL_BUILDING:
                 print(
                     f"Model is building... (elapsed {time.time() - st:.1f}s)", end='\r', flush=True

clarifai/runners/models/model_class.py

@@ -9,7 +9,6 @@ from typing import Any, Dict, Iterator, List
 
 from clarifai_grpc.grpc.api import resources_pb2, service_pb2
 from clarifai_grpc.grpc.api.status import status_code_pb2, status_pb2
-from google.protobuf import json_format
 
 from clarifai.runners.utils import data_types
 from clarifai.runners.utils.data_utils import DataConverter
@@ -100,7 +99,6 @@ class ModelClass(ABC):
         try:
             # TODO add method name field to proto
             method_name = 'predict'
-            inference_params = get_inference_params(request)
             if len(request.inputs) > 0 and '_method_name' in request.inputs[0].data.metadata:
                 method_name = request.inputs[0].data.metadata['_method_name']
             if (
@@ -124,7 +122,7 @@ class ModelClass(ABC):
                     input.data.CopyFrom(new_data)
             # convert inputs to python types
             inputs = self._convert_input_protos_to_python(
-                request.inputs, inference_params, signature.input_fields, python_param_types
+                request.inputs, signature.input_fields, python_param_types
             )
             if len(inputs) == 1:
                 inputs = inputs[0]
@@ -163,7 +161,6 @@ class ModelClass(ABC):
     ) -> Iterator[service_pb2.MultiOutputResponse]:
         try:
             method_name = 'generate'
-            inference_params = get_inference_params(request)
             if len(request.inputs) > 0 and '_method_name' in request.inputs[0].data.metadata:
                 method_name = request.inputs[0].data.metadata['_method_name']
             method = getattr(self, method_name)
@@ -180,7 +177,7 @@ class ModelClass(ABC):
                     )
                     input.data.CopyFrom(new_data)
             inputs = self._convert_input_protos_to_python(
-                request.inputs, inference_params, signature.input_fields, python_param_types
+                request.inputs, signature.input_fields, python_param_types
             )
             if len(inputs) == 1:
                 inputs = inputs[0]
@@ -226,7 +223,6 @@ class ModelClass(ABC):
             assert len(request.inputs) == 1, "Streaming requires exactly one input"
 
             method_name = 'stream'
-            inference_params = get_inference_params(request)
             if len(request.inputs) > 0 and '_method_name' in request.inputs[0].data.metadata:
                 method_name = request.inputs[0].data.metadata['_method_name']
             method = getattr(self, method_name)
@@ -251,7 +247,7 @@ class ModelClass(ABC):
                     input.data.CopyFrom(new_data)
             # convert all inputs for the first request, including the first stream value
             inputs = self._convert_input_protos_to_python(
-                request.inputs, inference_params, signature.input_fields, python_param_types
+                request.inputs, signature.input_fields, python_param_types
             )
             kwargs = inputs[0]
 
@@ -264,7 +260,7 @@ class ModelClass(ABC):
                 # subsequent streaming items contain only the streaming input
                 for request in request_iterator:
                     item = self._convert_input_protos_to_python(
-                        request.inputs, inference_params, [stream_sig], python_param_types
+                        request.inputs, [stream_sig], python_param_types
                     )
                     item = item[0][stream_argname]
                     yield item
@@ -297,13 +293,12 @@ class ModelClass(ABC):
     def _convert_input_protos_to_python(
         self,
         inputs: List[resources_pb2.Input],
-        inference_params: dict,
         variables_signature: List[resources_pb2.ModelTypeField],
         python_param_types,
     ) -> List[Dict[str, Any]]:
         result = []
         for input in inputs:
-            kwargs = deserialize(input.data, variables_signature, inference_params)
+            kwargs = deserialize(input.data, variables_signature)
             # dynamic cast to annotated types
             for k, v in kwargs.items():
                 if k not in python_param_types:
@@ -374,18 +369,6 @@ class ModelClass(ABC):
         return method_info
 
 
-# Helper function to get the inference params
-def get_inference_params(request) -> dict:
-    """Get the inference params from the request."""
-    inference_params = {}
-    if request.model.model_version.id != "":
-        output_info = request.model.model_version.output_info
-        output_info = json_format.MessageToDict(output_info, preserving_proto_field_name=True)
-        if "params" in output_info:
-            inference_params = output_info["params"]
-    return inference_params
-
-
 class _MethodInfo:
     def __init__(self, method):
         self.name = method.__name__

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/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',

clarifai/runners/utils/data_utils.py

@@ -1,9 +1,12 @@
+import json
+import math
+import operator
 from io import BytesIO
 from typing import List
 
 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 InputFieldProto
+from clarifai_grpc.grpc.api.resources_pb2 import ModelTypeField as ParamProto
 from PIL import Image
 
 from clarifai.runners.utils.data_types import MessageData
@@ -57,24 +60,25 @@ def is_openai_chat_format(messages):
     return True
 
 
-class InputField(MessageData):
+class Param(MessageData):
     """A field that can be used to store input data."""
 
     def __init__(
         self,
-        default=None,
+        default,
         description=None,
         min_value=None,
         max_value=None,
         choices=None,
-        #  is_param=True
+        is_param=True,
     ):
         self.default = default
         self.description = description
         self.min_value = min_value
         self.max_value = max_value
         self.choices = choices
-        # self.is_param = is_param
+        self.is_param = is_param
+        self._patch_encoder()
 
     def __repr__(self) -> str:
         attrs = []
@@ -88,12 +92,189 @@ class InputField(MessageData):
             attrs.append(f"max_value={self.max_value!r}")
         if self.choices is not None:
             attrs.append(f"choices={self.choices!r}")
-        # attrs.append(f"is_param={self.is_param!r}")
-        return f"InputField({', '.join(attrs)})"
+        attrs.append(f"is_param={self.is_param!r}")
+        return f"Param({', '.join(attrs)})"
 
-    def to_proto(self, proto=None) -> InputFieldProto:
+    # All *explicit* conversions
+    def __int__(self):
+        return int(self.default)
+
+    def __float__(self):
+        return float(self.default)
+
+    def __str__(self):
+        return str(self.default)
+
+    def __bool__(self):
+        return bool(self.default)
+
+    def __index__(self):
+        return int(self.default)  # for slicing
+
+    # sequence / mapping protocol delegation
+    def __len__(self):
+        return len(self.default)
+
+    def __iter__(self):
+        return iter(self.default)
+
+    def __reversed__(self):
+        return reversed(self.default)
+
+    def __contains__(self, item):
+        return item in self.default
+
+    def __getitem__(self, key):
+        return self.default[key]
+
+    def __setitem__(self, k, v):
+        self.default[k] = v
+
+    def __delitem__(self, k):
+        del self.default[k]
+
+    def __hash__(self):
+        return hash(self.default)
+
+    def __call__(self, *args, **kwargs):
+        return self.default(*args, **kwargs)
+
+    # Comparison operators
+    def __eq__(self, other):
+        return self.default == other
+
+    def __lt__(self, other):
+        return self.default < other
+
+    def __le__(self, other):
+        return self.default <= other
+
+    def __gt__(self, other):
+        return self.default > other
+
+    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,
+        "__sub__": operator.sub,
+        "__mul__": operator.mul,
+        "__truediv__": operator.truediv,
+        "__floordiv__": operator.floordiv,
+        "__mod__": operator.mod,
+        "__pow__": operator.pow,
+        "__and__": operator.and_,
+        "__or__": operator.or_,
+        "__xor__": operator.xor,
+        "__lshift__": operator.lshift,
+        "__rshift__": operator.rshift,
+    }
+
+    for _name, _op in _arith_ops.items():
+
+        def _make(op):
+            def _f(self, other, *, _op=op):  # default arg binds op
+                return _op(self.default, other)
+
+            return _f
+
+        locals()[_name] = _make(_op)
+        locals()["__r" + _name[2:]] = _make(lambda x, y, _op=_op: _op(y, x))
+    del _name, _op, _make
+
+    # In-place operators
+    _inplace_ops = {
+        "__iadd__": operator.iadd,
+        "__isub__": operator.isub,
+        "__imul__": operator.imul,
+        "__itruediv__": operator.itruediv,
+        "__ifloordiv__": operator.ifloordiv,
+        "__imod__": operator.imod,
+        "__ipow__": operator.ipow,
+        "__ilshift__": operator.ilshift,
+        "__irshift__": operator.irshift,
+        "__iand__": operator.iand,
+        "__ixor__": operator.ixor,
+        "__ior__": operator.ior,
+    }
+
+    for _name, _op in _inplace_ops.items():
+
+        def _make_inplace(op):
+            def _f(self, other, *, _op=op):
+                self.default = _op(self.default, other)
+                return self
+
+            return _f
+
+        locals()[_name] = _make_inplace(_op)
+    del _name, _op, _make_inplace
+
+    # Formatting and other conversions
+    def __format__(self, format_spec):
+        return format(self.default, format_spec)
+
+    def __bytes__(self):
+        return bytes(self.default)
+
+    def __complex__(self):
+        return complex(self.default)
+
+    def __round__(self, ndigits=None):
+        return round(self.default, ndigits)
+
+    def __trunc__(self):
+        return math.trunc(self.default)
+
+    def __floor__(self):
+        return math.floor(self.default)
+
+    def __ceil__(self):
+        return math.ceil(self.default)
+
+    # Attribute access delegation – anything we did *not* define above
+    # will automatically be looked up on the wrapped default value.
+    # Attribute access delegation
+    def __getattr__(self, item):
+        return getattr(self.default, item)
+
+    def __get__(self, instance, owner):
+        if instance is None:
+            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 = InputFieldProto()
+            proto = ParamProto()
         if self.description is not None:
             proto.description = self.description
 
@@ -102,7 +283,7 @@ class InputField(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()
@@ -111,7 +292,7 @@ class InputField(MessageData):
             if self.max_value is not None:
                 range_info.max = float(self.max_value)
             proto.model_type_range_info.CopyFrom(range_info)
-        # proto.is_param = self.is_param
+        proto.is_param = self.is_param
 
         if self.default is not None:
             proto = self.set_default(proto, self.default)
@@ -162,7 +343,7 @@ class InputField(MessageData):
             min_value=min_value,
             max_value=max_value,
             choices=choices,
-            # is_param=proto.is_param
+            is_param=proto.is_param,
         )
 
     @classmethod
@@ -171,9 +352,8 @@ class InputField(MessageData):
             import json
 
             if proto is None:
-                proto = InputFieldProto()
-            if default is not None:
-                proto.default = json.dumps(default)
+                proto = ParamProto()
+            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

@@ -161,10 +161,10 @@ def build_variable_signature(name, annotation, default=inspect.Parameter.empty,
     if not is_output:
         sig.required = default is inspect.Parameter.empty
         if not sig.required:
-            if isinstance(default, data_utils.InputField):
+            if isinstance(default, data_utils.Param):
                 sig = default.to_proto(sig)
             else:
-                sig = data_utils.InputField.set_default(sig, default)
+                sig = data_utils.Param.set_default(sig, default)
 
     _fill_signature_type(sig, tp)
 
@@ -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

clarifai/utils/logging.py

@@ -10,6 +10,8 @@ import traceback
 from collections import defaultdict
 from typing import Any, Dict, List, Optional, Union
 
+from clarifai.errors import UserError
+
 # The default logger to use throughout the SDK is defined at bottom of this file.
 
 # For the json logger.
@@ -80,8 +82,13 @@ def get_req_id_from_context():
 
 def display_workflow_tree(nodes_data: List[Dict]) -> None:
     """Displays a tree of the workflow nodes."""
-    from rich import print as rprint
-    from rich.tree import Tree
+    try:
+        from rich import print as rprint
+        from rich.tree import Tree
+    except ImportError:
+        raise UserError(
+            "Rich library is not installed. Please install it using pip install rich>=13.4.2"
+        )
 
     # Create a mapping of node_id to the list of node_ids that are connected to it.
     node_adj_mapping = defaultdict(list)
@@ -131,7 +138,12 @@ def display_workflow_tree(nodes_data: List[Dict]) -> None:
 
 def table_from_dict(data: List[Dict], column_names: List[str], title: str = "") -> 'rich.Table':  # noqa F821
     """Use this function for printing tables from a list of dicts."""
-    from rich.table import Table
+    try:
+        from rich.table import Table
+    except ImportError:
+        raise UserError(
+            "Rich library is not installed. Please install it using pip install rich>=13.4.2"
+        )
 
     table = Table(title=title, show_lines=False, show_header=True, header_style="blue")
     for column_name in column_names:
@@ -233,8 +245,13 @@ def display_concept_relations_tree(relations_dict: Dict[str, Any]) -> None:
     Args:
         relations_dict (dict): A dict of concept relations info.
     """
-    from rich import print as rprint
-    from rich.tree import Tree
+    try:
+        from rich import print as rprint
+        from rich.tree import Tree
+    except ImportError:
+        raise UserError(
+            "Rich library is not installed. Please install it using pip install rich>=13.4.2"
+        )
 
     for parent, children in relations_dict.items():
         tree = Tree(parent)

{clarifai-11.4.0.dist-info → clarifai-11.4.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clarifai
-Version: 11.4.0
+Version: 11.4.2
 Home-page: https://github.com/Clarifai/clarifai-python
 Author: Clarifai
 Author-email: support@clarifai.com
@@ -23,7 +23,6 @@ Requires-Dist: clarifai-grpc>=11.3.4
 Requires-Dist: clarifai-protocol>=0.0.23
 Requires-Dist: numpy>=1.22.0
 Requires-Dist: tqdm>=4.65.0
-Requires-Dist: rich>=13.4.2
 Requires-Dist: PyYAML>=6.0.1
 Requires-Dist: schema==0.7.5
 Requires-Dist: Pillow>=9.5.0

{clarifai-11.4.0.dist-info → clarifai-11.4.2.dist-info}/RECORD

@@ -1,4 +1,4 @@
-clarifai/__init__.py,sha256=BwRWbRM_tZXVkDcgICneVKgWcL8fV17tU6AnkSrIQbU,23
+clarifai/__init__.py,sha256=pSlLOPfmtDJ3YrQTjGkuoViOvxNtsJ3x0m9xPOysJPQ,23
 clarifai/cli.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 clarifai/errors.py,sha256=GXa6D4v_L404J83jnRNFPH7s-1V9lk7w6Ws99f1g-AY,2772
 clarifai/versions.py,sha256=ecSuEB_nOL2XSoYHDw2n23XUbm_KPOGjudMXmQrGdS8,224
@@ -14,7 +14,7 @@ clarifai/client/__init__.py,sha256=NhpNFRJY6mTi8ca-5hUeTEmYeDKHDNXY48FN63pDuos,7
 clarifai/client/app.py,sha256=LmIz06Tf1SVNd5SdLV5iqttEiY1x_8r5zX85MCfuXlo,41344
 clarifai/client/base.py,sha256=zOmB5HJP_-NmF2BPka14W7VUeJ1OF-fNxeacLsaRj3E,8775
 clarifai/client/compute_cluster.py,sha256=Tf4Svvx96pC2dMwdtpUsMiope-Nq941dpOViH4uDx5k,10218
-clarifai/client/dataset.py,sha256=AMFlOIMa7Rvn9BDAM6bDXxhvnYv9a1fAEOwM5hswtaU,35043
+clarifai/client/dataset.py,sha256=lsHrY2yxN_zfTGWzE_Gp7W_oi2G6BW2kPvAmKv6FyVE,35263
 clarifai/client/deployment.py,sha256=MQ3Kd8Ldp_JTC1hqhRqPiHe0RVUjb6iBY5DiA2Q7NxA,2839
 clarifai/client/input.py,sha256=Oswf3sp8PLs39jGIqfbJ89afh9GTCSsaQ--lYPtEtRo,51169
 clarifai/client/lister.py,sha256=1YEm2suNxPaJO4x9V5szgD_YX6N_00vgSO-7m0HagY8,2208
@@ -67,17 +67,19 @@ clarifai/runners/__init__.py,sha256=cDJ31l41dDsqW4Xn6sFMkKxxdIMTnGH9IW6sVkq0TNw,
 clarifai/runners/server.py,sha256=9qVAs8pRHmtyY0RCNIQ1uP8nqDADIFZ03LnkoDt1h4U,4692
 clarifai/runners/dockerfile_template/Dockerfile.template,sha256=5cjv7U8PmWa3DB_5B1CqSYh_6GE0E0np52TIAa7EIDE,2312
 clarifai/runners/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-clarifai/runners/models/model_builder.py,sha256=BupeN3yforFC-BadSTYQ3zoSBzi27Of2DCy0PD0zrkM,42511
-clarifai/runners/models/model_class.py,sha256=MRmLmRlC5J0FmiesrlQm-plMu1VzUSnKNEDOXZfYQ00,16409
-clarifai/runners/models/model_run_locally.py,sha256=l5P-BbcWlDkKdOPnsmZJPxkNkY85oah_sBaW5IVOz5M,20286
+clarifai/runners/models/model_builder.py,sha256=8Rj5nxDUa_jpDBQ04tD0hztenzXKcx2OEg4ce9ELY4I,48237
+clarifai/runners/models/model_class.py,sha256=OHVd0tMOXDyl9v1vWeHOmYGx_dvP77N4zlLGMyTakag,15575
+clarifai/runners/models/model_run_locally.py,sha256=6-6WjEKc0ba3gAv4wOLdMs2XOzS3b-2bZHJS0wdVqJY,20088
 clarifai/runners/models/model_runner.py,sha256=SccX-RxTgruSpQaM21uMSl-z1x6fOa13fQZMQW8NNRY,7297
 clarifai/runners/models/model_servicer.py,sha256=rRd_fNEXwqiBSzTUtPI2r07EBdcCPd8tcSPHeqTe0_I,3445
+clarifai/runners/models/visual_classifier_class.py,sha256=f9ZP8KFamMUdMpUG3AlL9nVCdcggy_E5n9RJY3ixR1U,2739
+clarifai/runners/models/visual_detector_class.py,sha256=ky4oFAkGCKPpGPdgaOso-n6D3HcmnbKee_8hBsNiV8U,2883
 clarifai/runners/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-clarifai/runners/utils/code_script.py,sha256=CeIhBYX-vB17ThQy5x4ObQoehYo3w4Nms5Qh1p5pTDk,10382
-clarifai/runners/utils/const.py,sha256=czPVidLCb2S1HbA8YbNkoDYphqr0-W7oeqrkf8LsTc4,1068
-clarifai/runners/utils/data_utils.py,sha256=NBmIdHliue4w9MFsf36QEwmerRCVRNbArpv3ekDkYxU,14850
-clarifai/runners/utils/loader.py,sha256=KliTvPgi_7SkN3PhOeDFDATRaKFbqRU4CxOq6Gkh9T0,10070
-clarifai/runners/utils/method_signatures.py,sha256=AJjjiG4V8CmoMarCZGY8Dsh7P7th5eqIvBnTINCpOmw,19232
+clarifai/runners/utils/code_script.py,sha256=M3S8c5XBMdY_VFsirLxdFRrC-PCqk1Tul0_qbm_89l4,10394
+clarifai/runners/utils/const.py,sha256=Q4Ps6gIEJCyTdQCfmT6PaS61WHmhT25XigV1NugWz-E,1544
+clarifai/runners/utils/data_utils.py,sha256=phrqojg3zhKDZxgXFdxL0NVLkuV0abbOLOSQPIGPPVI,19744
+clarifai/runners/utils/loader.py,sha256=K5Y8MPbIe5STw2gDnrL8KqFgKNxEo7bz-RV0ip1T4PM,10900
+clarifai/runners/utils/method_signatures.py,sha256=3EqrTLxynaBC4clj23iw9fZApFDQeapCzVlre6uybbI,19152
 clarifai/runners/utils/openai_convertor.py,sha256=QhbytqGU856gEFggaamZy01hhCwjiWz8ju48iubvbeI,5074
 clarifai/runners/utils/serializers.py,sha256=pI7GqMTC0T3Lu_X8v8TO4RiplO-gC_49Ns37jYwsPtg,7908
 clarifai/runners/utils/url_fetcher.py,sha256=Segkvi-ktPa3-koOpUu8DNZeWOaK6G82Ya9b7_oIKwo,1778
@@ -89,7 +91,7 @@ clarifai/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 clarifai/utils/cli.py,sha256=7lHajIsWzyEU7jfgH1nykwYG63wcHCZ3ep7a6amWZH4,5413
 clarifai/utils/config.py,sha256=-mZwJEtv31pfchavgmiaNxRgwbcUhWpxJATH2hU8kwQ,4591
 clarifai/utils/constants.py,sha256=goxDnTuI6jtDhP2pWasMGcfd4FL3k6qUs2PE67EZOeM,1882
-clarifai/utils/logging.py,sha256=DY6lsr-w6t56JrPovKBe82lvmDNO0foNnx1Mz_swY3w,14653
+clarifai/utils/logging.py,sha256=0we53uTqUvzrulC86whu-oeWNxn1JjJL0OQ98Bwf9vo,15198
 clarifai/utils/misc.py,sha256=x7JP8oxU672Z9yAav47Y1anFiL4RD8WvlKBHMVlbyZM,3137
 clarifai/utils/model_train.py,sha256=0XSAoTkSsrwf4f-W9yw2mkXZtkal7LBLJSoi86CFCn4,9250
 clarifai/utils/protobuf.py,sha256=VMhnNsPuWQ16VarKm8BOr5zccXMe26UlrxdJxIzEZNM,6220
@@ -101,9 +103,9 @@ clarifai/workflows/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuF
 clarifai/workflows/export.py,sha256=Oq3RVNKvv1iH46U6oIjXa-MXWJ4sTlXr_NSfwoxr3H4,2149
 clarifai/workflows/utils.py,sha256=ESL3INcouNcLKCh-nMpfXX-YbtCzX7tz7hT57_RGQ3M,2079
 clarifai/workflows/validate.py,sha256=UhmukyHkfxiMFrPPeBdUTiCOHQT5-shqivlBYEyKTlU,2931
-clarifai-11.4.0.dist-info/licenses/LICENSE,sha256=mUqF_d12-qE2n41g7C5_sq-BMLOcj6CNN-jevr15YHU,555
-clarifai-11.4.0.dist-info/METADATA,sha256=tmZl9rxAD8_VIIFZRq4eSE3CTb-S4VjEDOxd1KIomPQ,22426
-clarifai-11.4.0.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
-clarifai-11.4.0.dist-info/entry_points.txt,sha256=X9FZ4Z-i_r2Ud1RpZ9sNIFYuu_-9fogzCMCRUD9hyX0,51
-clarifai-11.4.0.dist-info/top_level.txt,sha256=wUMdCQGjkxaynZ6nZ9FAnvBUCgp5RJUVFSy2j-KYo0s,9
-clarifai-11.4.0.dist-info/RECORD,,
+clarifai-11.4.2.dist-info/licenses/LICENSE,sha256=mUqF_d12-qE2n41g7C5_sq-BMLOcj6CNN-jevr15YHU,555
+clarifai-11.4.2.dist-info/METADATA,sha256=8ezcxLu3AgPvciJRlpPHEXWoJCfmzrliSXPhTN9nwaM,22398
+clarifai-11.4.2.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+clarifai-11.4.2.dist-info/entry_points.txt,sha256=X9FZ4Z-i_r2Ud1RpZ9sNIFYuu_-9fogzCMCRUD9hyX0,51
+clarifai-11.4.2.dist-info/top_level.txt,sha256=wUMdCQGjkxaynZ6nZ9FAnvBUCgp5RJUVFSy2j-KYo0s,9
+clarifai-11.4.2.dist-info/RECORD,,

{clarifai-11.4.0.dist-info → clarifai-11.4.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.3.1)
+Generator: setuptools (80.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any