clarifai 11.5.1__py3-none-any.whl → 11.5.3__py3-none-any.whl

clarifai/runners/pipelines/pipeline_builder.py

@@ -0,0 +1,313 @@
+import json
+import os
+import sys
+from typing import Any, Dict
+
+import yaml
+from clarifai_grpc.grpc.api import resources_pb2, service_pb2
+from clarifai_grpc.grpc.api.status import status_code_pb2
+
+from clarifai.client.base import BaseClient
+from clarifai.runners.utils.pipeline_validation import PipelineConfigValidator
+from clarifai.utils.logging import logger
+
+
+class LiteralBlockDumper(yaml.SafeDumper):
+    """Custom YAML dumper that uses literal block style for multi-line strings."""
+
+    def represent_str(self, data):
+        if '\n' in data:
+            return self.represent_scalar('tag:yaml.org,2002:str', data, style='|')
+        return self.represent_scalar('tag:yaml.org,2002:str', data)
+
+
+LiteralBlockDumper.add_representer(str, LiteralBlockDumper.represent_str)
+
+
+class PipelineBuilder:
+    """Pipeline Builder class for managing pipeline upload to Clarifai."""
+
+    def __init__(self, config_path: str):
+        """
+        Initialize PipelineBuilder.
+
+        :param config_path: Path to the pipeline configuration file
+        """
+        self._client = None
+        self.config_path = os.path.abspath(config_path)
+        self.config_dir = os.path.dirname(self.config_path)
+        self.config = self._load_config()
+        self.validator = PipelineConfigValidator()
+        self.validator.validate_config(self.config)
+
+        # Extract pipeline info
+        pipeline_config = self.config["pipeline"]
+        self.pipeline_id = pipeline_config["id"]
+        self.user_id = pipeline_config["user_id"]
+        self.app_id = pipeline_config["app_id"]
+
+        # Track uploaded pipeline step versions
+        self.uploaded_step_versions = {}
+
+    @property
+    def client(self):
+        """Get or create the Clarifai client."""
+        if self._client is None:
+            self._client = BaseClient(user_id=self.user_id, app_id=self.app_id)
+        return self._client
+
+    def _load_config(self) -> Dict[str, Any]:
+        """Load and return the configuration from config file."""
+        try:
+            with open(self.config_path, 'r') as file:
+                config = yaml.safe_load(file)
+            return config
+        except Exception as e:
+            raise ValueError(f"Error loading config file {self.config_path}: {e}")
+
+    def _save_config(self) -> None:
+        """Save the updated configuration back to the file."""
+        try:
+            with open(self.config_path, 'w', encoding="utf-8") as file:
+                yaml.dump(
+                    self.config,
+                    file,
+                    Dumper=LiteralBlockDumper,
+                    default_flow_style=False,
+                    sort_keys=False,
+                )
+        except Exception as e:
+            raise ValueError(f"Error saving config file {self.config_path}: {e}")
+
+    def upload_pipeline_steps(self) -> bool:
+        """Upload all pipeline steps listed in step_directories."""
+        pipeline_config = self.config["pipeline"]
+        step_directories = pipeline_config.get("step_directories", [])
+
+        if not step_directories:
+            logger.info("No pipeline steps to upload (step_directories is empty)")
+            return True
+
+        logger.info(f"Uploading {len(step_directories)} pipeline steps...")
+
+        for step_dir in step_directories:
+            step_path = os.path.join(self.config_dir, step_dir)
+
+            if not os.path.exists(step_path):
+                logger.error(f"Pipeline step directory not found: {step_path}")
+                return False
+
+            logger.info(f"Uploading pipeline step from directory: {step_dir}")
+
+            # Create a backup of the original upload function to capture the version
+            # We'll need to modify the upload process to capture the version ID
+            success, version_id = self._upload_pipeline_step_with_version_capture(step_path)
+
+            if not success:
+                logger.error(f"Failed to upload pipeline step from directory: {step_dir}")
+                return False
+
+            # Store the version ID for later use
+            self.uploaded_step_versions[step_dir] = version_id
+            logger.info(
+                f"Successfully uploaded pipeline step {step_dir} with version {version_id}"
+            )
+
+        return True
+
+    def _upload_pipeline_step_with_version_capture(self, step_path: str) -> tuple[bool, str]:
+        """Upload a pipeline step and capture its version ID."""
+        try:
+            # Use the existing pipeline step builder
+            from clarifai.runners.pipeline_steps.pipeline_step_builder import PipelineStepBuilder
+
+            builder = PipelineStepBuilder(step_path)
+
+            # Create dockerfile if needed
+            builder.create_dockerfile()
+
+            # Check if step exists
+            exists = builder.check_pipeline_step_exists()
+            if exists:
+                logger.info(
+                    f"Pipeline step {builder.pipeline_step_id} already exists, creating new version"
+                )
+            else:
+                logger.info(f"Creating new pipeline step {builder.pipeline_step_id}")
+
+            # Upload the pipeline step version directly without the interactive prompt
+            success = builder.upload_pipeline_step_version()
+
+            if success and builder.pipeline_step_version_id:
+                return True, builder.pipeline_step_version_id
+            else:
+                logger.error("Failed to get pipeline step version ID after upload")
+                return False, ""
+
+        except Exception as e:
+            logger.error(f"Error uploading pipeline step: {e}")
+            return False, ""
+
+    def update_config_with_versions(self) -> None:
+        """Update the config.yaml with uploaded pipeline step versions."""
+        if not self.uploaded_step_versions:
+            logger.info("No pipeline step versions to update in config")
+            return
+
+        logger.info("Updating config.yaml with pipeline step versions...")
+
+        # Update the orchestration spec
+        pipeline_config = self.config["pipeline"]
+        orchestration_spec = pipeline_config["orchestration_spec"]
+        argo_spec_str = orchestration_spec["argo_orchestration_spec"]
+        argo_spec = yaml.safe_load(argo_spec_str)
+
+        # Update templateRef names to include versions
+        self._update_template_refs_with_versions(argo_spec)
+
+        # Update the config
+        orchestration_spec["argo_orchestration_spec"] = yaml.dump(
+            argo_spec, Dumper=LiteralBlockDumper, default_flow_style=False
+        )
+
+        # Remove uploaded directories from step_directories
+        remaining_dirs = []
+        for step_dir in pipeline_config.get("step_directories", []):
+            if step_dir not in self.uploaded_step_versions:
+                remaining_dirs.append(step_dir)
+
+        pipeline_config["step_directories"] = remaining_dirs
+
+        # Save the updated config
+        self._save_config()
+        logger.info("Updated config.yaml with pipeline step versions")
+
+    def _update_template_refs_with_versions(self, argo_spec: Dict[str, Any]) -> None:
+        """Update templateRef names in Argo spec to include version information."""
+        for template in argo_spec["spec"]["templates"]:
+            if "steps" in template:
+                for step_group in template["steps"]:
+                    for step in step_group:
+                        if "templateRef" in step:
+                            template_ref = step["templateRef"]
+                            name = template_ref["name"]
+
+                            # Check if this is a templateRef without version that we uploaded
+                            if self.validator.TEMPLATE_REF_WITHOUT_VERSION_PATTERN.match(name):
+                                # Extract step name
+                                parts = name.split('/')
+                                step_name = parts[-1]
+
+                                # Find the corresponding directory and version
+                                for step_dir, version_id in self.uploaded_step_versions.items():
+                                    # The step name should match the directory name or be derivable from it
+                                    if step_name == step_dir:
+                                        # Update the templateRef to include version
+                                        new_name = f"{name}/versions/{version_id}"
+                                        template_ref["name"] = new_name
+                                        template_ref["template"] = new_name
+                                        logger.info(
+                                            f"Updated templateRef from {name} to {new_name}"
+                                        )
+                                        break
+
+    def create_pipeline(self) -> bool:
+        """Create the pipeline using PostPipelines RPC."""
+        logger.info(f"Creating pipeline {self.pipeline_id}...")
+
+        try:
+            # Create pipeline proto
+            pipeline = resources_pb2.Pipeline(
+                id=self.pipeline_id, user_id=self.user_id, app_id=self.app_id
+            )
+
+            # Add orchestration spec
+            pipeline_config = self.config["pipeline"]
+            orchestration_spec = pipeline_config["orchestration_spec"]
+            argo_spec_str = orchestration_spec["argo_orchestration_spec"]
+
+            # Parse the Argo spec to get API version
+            argo_spec = yaml.safe_load(argo_spec_str)
+            api_version = argo_spec.get("apiVersion", "argoproj.io/v1alpha1")
+
+            # Create pipeline version with orchestration spec
+            pipeline_version = resources_pb2.PipelineVersion()
+            # Create orchestration spec proto
+            orchestration_spec_proto = resources_pb2.OrchestrationSpec()
+            # Create Argo orchestration spec proto
+            argo_orchestration_spec_proto = resources_pb2.ArgoOrchestrationSpec()
+            argo_orchestration_spec_proto.api_version = api_version
+            argo_orchestration_spec_proto.spec_json = json.dumps(argo_spec)
+
+            orchestration_spec_proto.argo_orchestration_spec.CopyFrom(
+                argo_orchestration_spec_proto
+            )
+            pipeline_version.orchestration_spec.CopyFrom(orchestration_spec_proto)
+
+            pipeline.pipeline_version.CopyFrom(pipeline_version)
+
+            # Make the RPC call
+            response = self.client.STUB.PostPipelines(
+                service_pb2.PostPipelinesRequest(
+                    user_app_id=self.client.user_app_id, pipelines=[pipeline]
+                )
+            )
+
+            if response.status.code == status_code_pb2.SUCCESS:
+                logger.info(f"Successfully created pipeline {self.pipeline_id}")
+
+                # Log pipeline and version IDs if available in response
+                if response.pipelines:
+                    created_pipeline = response.pipelines[0]
+                    logger.info(f"Pipeline ID: {created_pipeline.id}")
+                    if created_pipeline.pipeline_version and created_pipeline.pipeline_version.id:
+                        logger.info(f"Pipeline version ID: {created_pipeline.pipeline_version.id}")
+
+                return True
+            else:
+                logger.error(f"Failed to create pipeline: {response.status.description}")
+                logger.error(f"Details: {response.status.details}")
+                return False
+
+        except Exception as e:
+            logger.error(f"Error creating pipeline: {e}")
+            return False
+
+
+def upload_pipeline(path: str):
+    """
+    Upload a pipeline with associated pipeline steps to Clarifai.
+
+    :param path: Path to the pipeline configuration file or directory containing config.yaml
+    """
+    try:
+        # Determine if path is a directory or file
+        if os.path.isdir(path):
+            config_path = os.path.join(path, "config.yaml")
+            if not os.path.exists(config_path):
+                raise FileNotFoundError(f"config.yaml not found in directory: {path}")
+        else:
+            config_path = path
+
+        builder = PipelineBuilder(config_path)
+
+        logger.info(f"Starting pipeline upload from config: {config_path}")
+
+        # Step 1: Upload pipeline steps
+        if not builder.upload_pipeline_steps():
+            logger.error("Failed to upload pipeline steps")
+            sys.exit(1)
+
+        # Step 2: Update config with version information
+        builder.update_config_with_versions()
+
+        # Step 3: Create the pipeline
+        if not builder.create_pipeline():
+            logger.error("Failed to create pipeline")
+            sys.exit(1)
+
+        logger.info("Pipeline upload completed successfully!")
+
+    except Exception as e:
+        logger.error(f"Pipeline upload failed: {e}")
+        sys.exit(1)

clarifai/runners/utils/code_script.py

@@ -28,6 +28,8 @@ def generate_client_script(
     model_id,
     base_url: str = None,
     deployment_id: str = None,
+    compute_cluster_id: str = None,
+    nodepool_id: str = None,
     use_ctx: bool = False,
 ) -> str:
     url_helper = ClarifaiUrlHelper()
@@ -96,15 +98,42 @@ from clarifai.client import Model
 from clarifai.runners.utils import data_types
 {model_section}
     """
+    if deployment_id and (compute_cluster_id or nodepool_id):
+        raise ValueError(
+            "You can only specify one of deployment_id or compute_cluster_id and nodepool_id."
+        )
+    if compute_cluster_id and nodepool_id:
+        deployment_id = None
+    else:
+        deployment_id = (
+            "os.environ['CLARIFAI_DEPLOYMENT_ID']" if not deployment_id else repr(deployment_id)
+        )
 
-    deployment_id = (
-        "os.environ['CLARIFAI_DEPLOYMENT_ID']" if deployment_id is None else deployment_id
+    deployment_line = (
+        f'deployment_id = {deployment_id}, # Only needed for dedicated deployed models'
+        if deployment_id
+        else ""
+    )
+    compute_cluster_line = (
+        f'compute_cluster_id = "{compute_cluster_id}",' if compute_cluster_id else ""
+    )
+    nodepool_line = (
+        f'nodepool_id = "{nodepool_id}", # Only needed for dedicated nodepool'
+        if nodepool_id
+        else ""
     )
 
     base_url_str = ""
     if base_url is not None:
         base_url_str = f"base_url={base_url},"
 
+    # Join all non-empty lines
+    optional_lines = "\n    ".join(
+        line
+        for line in [deployment_line, compute_cluster_line, nodepool_line, base_url_str]
+        if line
+    )
+
     if use_ctx:
         model_section = """
 model = Model.from_current_context()"""
@@ -112,8 +141,7 @@ model = Model.from_current_context()"""
         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}
+    {optional_lines}
  )
 """
 
@@ -128,14 +156,19 @@ model = Model("{model_ui_url}",
         method_name = method_signature.name
         client_script_str = f'response = model.{method_name}('
         annotations = _get_annotations_source(method_signature)
-        for param_name, (param_type, default_value, required) in annotations.items():
+        for idx, (param_name, (param_type, default_value, required)) in enumerate(
+            annotations.items()
+        ):
             if param_name == "return":
                 continue
             if default_value is None and required:
                 default_value = _set_default_value(param_type)
+            if not default_value and idx == 0:
+                default_value = _set_default_value(param_type)
             if param_type == "str" and default_value is not None:
                 default_value = json.dumps(default_value)
-            client_script_str += f"{param_name}={default_value}, "
+            if default_value is not None:
+                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)"
@@ -229,7 +262,7 @@ def _map_default_value(field_type):
     default_value = None
 
     if field_type == "str":
-        default_value = repr('What is the future of AI?')
+        default_value = 'What is the future of AI?'
     elif field_type == "bytes":
         default_value = b""
     elif field_type == "int":

clarifai/runners/utils/const.py

@@ -4,7 +4,7 @@ registry = os.environ.get('CLARIFAI_BASE_IMAGE_REGISTRY', 'public.ecr.aws/clarif
 
 GIT_SHA = "42938da8e33b0f37ee7db16b83631da94c2348b9"
 
-AMD_GIT_SHA = "42938da8e33b0f37ee7db16b83631da94c2348b9"
+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
@@ -22,7 +22,7 @@ AVAILABLE_PYTHON_IMAGES = ['3.11', '3.12']
 
 DEFAULT_PYTHON_VERSION = '3.12'
 
-DEFAULT_AMD_TORCH_VERSION = '2.8.0.dev20250511+rocm6.4'
+DEFAULT_AMD_TORCH_VERSION = '2.8.0.dev20250514'
 
 DEFAULT_AMD_GPU_VERSION = 'rocm6.4'
 

clarifai/runners/utils/model_utils.py

@@ -0,0 +1,135 @@
+import os
+import shlex
+import signal
+import subprocess
+import sys
+import threading
+import time
+
+import psutil
+import requests
+
+from clarifai.utils.logging import logger
+
+
+def kill_process_tree(parent_pid, include_parent: bool = True, skip_pid: int = None):
+    """Kill the process and all its child processes.
+
+    Args:
+        parent_pid (int): The PID of the parent process to kill. If None, uses current process.
+        include_parent (bool): Whether to kill the parent process as well.
+        skip_pid (int, optional): PID to skip when killing child processes.
+
+    Raises:
+        psutil.AccessDenied: If process cannot be accessed due to permissions.
+        psutil.NoSuchProcess: If process does not exist.
+    """
+    # Remove sigchld handler to avoid spammy logs.
+    if threading.current_thread() is threading.main_thread():
+        signal.signal(signal.SIGCHLD, signal.SIG_DFL)
+
+    if parent_pid is None:
+        parent_pid = os.getpid()
+        include_parent = False
+
+    try:
+        itself = psutil.Process(parent_pid)
+    except psutil.NoSuchProcess:
+        logger.warning(f"Process {parent_pid} does not exist")
+        return
+    except psutil.AccessDenied:
+        logger.error(f"Cannot access process {parent_pid} due to permissions")
+        raise
+
+    children = itself.children(recursive=True)
+    for child in children:
+        if child.pid == skip_pid:
+            continue
+        try:
+            child.kill()
+        except (psutil.NoSuchProcess, psutil.AccessDenied) as e:
+            logger.warning(f"Failed to kill child process {child.pid}: {e}")
+
+    if include_parent:
+        try:
+            if parent_pid == os.getpid():
+                itself.kill()
+                sys.exit(0)
+
+            itself.kill()
+
+            # Sometime processes cannot be killed with SIGKILL (e.g, PID=1 launched by kubernetes),
+            # so we send an additional signal to kill them.
+            if hasattr(signal, 'SIGQUIT'):
+                itself.send_signal(signal.SIGQUIT)
+        except (psutil.NoSuchProcess, psutil.AccessDenied) as e:
+            logger.warning(f"Failed to kill parent process {parent_pid}: {e}")
+
+
+def execute_shell_command(
+    command: str,
+) -> subprocess.Popen:
+    """Execute a shell command and return its process handle.
+
+    Args:
+        command (str): The shell command to execute.
+
+    Returns:
+        subprocess.Popen: Process handle for the executed command.
+
+    Raises:
+        ValueError: If command is empty or invalid.
+        subprocess.SubprocessError: If command execution fails.
+    """
+    if not command or not isinstance(command, str):
+        raise ValueError("command must be a non-empty string")
+
+    command = command.replace("\\\n", " ").replace("\\", " ")
+    parts = shlex.split(command)
+
+    try:
+        process = subprocess.Popen(parts, text=True, stderr=subprocess.STDOUT)
+
+        return process
+    except subprocess.SubprocessError as e:
+        logger.error(f"Failed to execute command: {e}")
+        raise
+
+
+def terminate_process(process):
+    """
+    Terminate the process
+    """
+    kill_process_tree(process.pid)
+
+
+def wait_for_server(base_url: str, timeout: int = None) -> None:
+    """Wait for the server to be ready by polling the /v1/models endpoint.
+
+    Args:
+        base_url: The base URL of the server
+        timeout: Maximum time to wait in seconds. None means wait forever.
+    """
+    start_time = time.perf_counter()
+    while True:
+        try:
+            response = requests.get(
+                f"{base_url}/v1/models",
+                headers={"Authorization": "Bearer None"},
+            )
+            if response.status_code == 200:
+                time.sleep(5)
+                logger.info(
+                    """\n
+                    NOTE: Typically, the server runs in a separate terminal.
+                    In this notebook, we run the server and notebook code together, so their outputs are combined.
+                    To improve clarity, the server logs are displayed in the original black color, while the notebook outputs are highlighted in blue.
+                    We are running those notebooks in a CI parallel environment, so the throughput is not representative of the actual performance.
+                    """
+                )
+                break
+
+            if timeout and time.perf_counter() - start_time > timeout:
+                raise TimeoutError("Server did not become ready within timeout period")
+        except requests.exceptions.RequestException:
+            time.sleep(1)