clarifai 11.6.5__py3-none-any.whl → 11.6.7__py3-none-any.whl

clarifai/client/app.py

@@ -14,6 +14,8 @@ from clarifai.client.input import Inputs
 from clarifai.client.lister import Lister
 from clarifai.client.model import Model
 from clarifai.client.module import Module
+from clarifai.client.pipeline import Pipeline
+from clarifai.client.pipeline_step import PipelineStep
 from clarifai.client.search import Search
 from clarifai.client.workflow import Workflow
 from clarifai.constants.model import TRAINABLE_MODEL_TYPES
@@ -198,6 +200,151 @@ class App(Lister, BaseClient):
                     continue
             yield Workflow.from_auth_helper(auth=self.auth_helper, **workflow_info)
 
+    def list_pipelines(
+        self,
+        filter_by: Dict[str, Any] = {},
+        only_in_app: bool = True,
+        page_no: int = None,
+        per_page: int = None,
+    ) -> Generator[dict, None, None]:
+        """Lists all the pipelines for the user.
+
+        Args:
+            filter_by (dict): A dictionary of filters to apply to the list of pipelines.
+            only_in_app (bool): If True, only return pipelines that are in the app.
+            page_no (int): The page number to list.
+            per_page (int): The number of items per page.
+
+        Yields:
+            Dict: Dictionaries containing information about the pipelines.
+
+        Example:
+            >>> from clarifai.client.app import App
+            >>> app = App(app_id="app_id", user_id="user_id")
+            >>> all_pipelines = list(app.list_pipelines())
+
+        Note:
+            Defaults to 16 per page if page_no is specified and per_page is not specified.
+            If both page_no and per_page are None, then lists all the resources.
+        """
+        request_data = dict(user_app_id=self.user_app_id, **filter_by)
+        all_pipelines_info = self.list_pages_generator(
+            self.STUB.ListPipelines,
+            service_pb2.ListPipelinesRequest,
+            request_data,
+            per_page=per_page,
+            page_no=page_no,
+        )
+
+        for pipeline_info in all_pipelines_info:
+            pipeline = self._process_pipeline_info(
+                pipeline_info, self.auth_helper, self.id, only_in_app
+            )
+            if pipeline is not None:
+                yield pipeline
+
+    @staticmethod
+    def _process_pipeline_info(pipeline_info, auth_helper, app_id=None, only_in_app=False):
+        """Helper method to process pipeline info and create Pipeline objects.
+
+        Args:
+            pipeline_info: Raw pipeline info from API
+            auth_helper: Auth helper instance
+            app_id: App ID to filter by (if only_in_app is True)
+            only_in_app: Whether to filter by app_id
+
+        Returns:
+            Pipeline object or None if filtered out
+        """
+        if only_in_app and app_id:
+            if pipeline_info.get('app_id') != app_id:
+                return None
+
+        # Map API field names to constructor parameter names
+        pipeline_kwargs = pipeline_info.copy()
+        if 'id' in pipeline_kwargs:
+            pipeline_kwargs['pipeline_id'] = pipeline_kwargs.pop('id')
+        if 'pipeline_version' in pipeline_kwargs:
+            pipeline_version = pipeline_kwargs.pop('pipeline_version')
+            pipeline_kwargs['pipeline_version_id'] = pipeline_version.get('id', '')
+
+        return Pipeline.from_auth_helper(auth=auth_helper, **pipeline_kwargs)
+
+    @staticmethod
+    def _process_pipeline_step_info(
+        pipeline_step_info, auth_helper, app_id=None, only_in_app=False
+    ):
+        """Helper method to process pipeline step info and create PipelineStep objects.
+
+        Args:
+            pipeline_step_info: Raw pipeline step info from API
+            auth_helper: Auth helper instance
+            app_id: App ID to filter by (if only_in_app is True)
+            only_in_app: Whether to filter by app_id
+
+        Returns:
+            PipelineStep object or None if filtered out
+        """
+        if only_in_app and app_id:
+            if pipeline_step_info.get('app_id') != app_id:
+                return None
+
+        # Map API field names to constructor parameter names
+        step_kwargs = pipeline_step_info.copy()
+        if 'pipeline_step' in step_kwargs:
+            pipeline_step = step_kwargs.pop('pipeline_step')
+            step_kwargs['pipeline_step_id'] = pipeline_step.get('id', '')
+
+        return PipelineStep.from_auth_helper(auth=auth_helper, **step_kwargs)
+
+    def list_pipeline_steps(
+        self,
+        pipeline_id: str = None,
+        filter_by: Dict[str, Any] = {},
+        only_in_app: bool = True,
+        page_no: int = None,
+        per_page: int = None,
+    ) -> Generator[dict, None, None]:
+        """Lists all the pipeline steps for the user.
+
+        Args:
+            pipeline_id (str): If provided, only list pipeline steps from this pipeline.
+            filter_by (dict): A dictionary of filters to apply to the list of pipeline steps.
+            only_in_app (bool): If True, only return pipeline steps that are in the app.
+            page_no (int): The page number to list.
+            per_page (int): The number of items per page.
+
+        Yields:
+            Dict: Dictionaries containing information about the pipeline steps.
+
+        Example:
+            >>> from clarifai.client.app import App
+            >>> app = App(app_id="app_id", user_id="user_id")
+            >>> all_pipeline_steps = list(app.list_pipeline_steps())
+
+        Note:
+            Defaults to 16 per page if page_no is specified and per_page is not specified.
+            If both page_no and per_page are None, then lists all the resources.
+        """
+        request_data = dict(user_app_id=self.user_app_id, **filter_by)
+        if pipeline_id:
+            request_data['pipeline_id'] = pipeline_id
+
+        all_pipeline_steps_info = self.list_pages_generator(
+            self.STUB.ListPipelineStepVersions,
+            service_pb2.ListPipelineStepVersionsRequest,
+            request_data,
+            per_page=per_page,
+            page_no=page_no,
+        )
+
+        for pipeline_step_info in all_pipeline_steps_info:
+            pipeline_step = self._process_pipeline_step_info(
+                pipeline_step_info, self.auth_helper, self.id, only_in_app
+            )
+            if pipeline_step is not None:
+                yield pipeline_step
+
     def list_modules(
         self,
         filter_by: Dict[str, Any] = {},

clarifai/client/model_client.py

@@ -76,7 +76,22 @@ class ModelClient:
     def __getattr__(self, name):
         if not self._defined:
             self.fetch()
-        return self.__getattribute__(name)
+        try:
+            return self.__getattribute__(name)
+        except AttributeError as e:
+            # Provide helpful error message with available methods
+            available_methods = []
+            if self._method_signatures:
+                available_methods = list(self._method_signatures.keys())
+
+            error_msg = f"'{self.__class__.__name__}' object has no attribute '{name}'"
+
+            if available_methods:
+                error_msg += f". Available methods: {available_methods}"
+                raise AttributeError(error_msg) from e
+            else:
+                error_msg += ". This model is a non-pythonic model. Please use the old inference methods i.e. predict_by_url, predict_by_bytes, etc."
+                raise Exception(error_msg) from e
 
     def _fetch_signatures(self):
         '''
@@ -148,6 +163,10 @@ class ModelClient:
             self._define_compatability_functions()
             return
         if response.status.code != status_code_pb2.SUCCESS:
+            if response.outputs[0].status.description.startswith("cannot identify image file"):
+                raise Exception(
+                    "Failed to fetch method signatures from model and backup method. This model is a non-pythonic model. Please use the old inference methods i.e. predict_by_url, predict_by_bytes, etc."
+                )
             raise Exception(f"Model failed with response {response!r}")
         self._method_signatures = signatures_from_json(response.outputs[0].data.text.raw)
 

clarifai/client/nodepool.py

@@ -94,7 +94,9 @@ class Nodepool(Lister, BaseClient):
         ), "worker info not found in the config file"
         assert "scheduling_choice" in deployment, "scheduling_choice not found in the config file"
         assert "nodepools" in deployment, "nodepools not found in the config file"
-        deployment['user_id'] = self.user_app_id.user_id
+        deployment['user_id'] = (
+            deployment['user_id'] if 'user_id' in deployment else self.user_app_id.user_id
+        )
         if "autoscale_config" in deployment:
             deployment['autoscale_config'] = resources_pb2.AutoscaleConfig(
                 **deployment['autoscale_config']
@@ -103,7 +105,10 @@ class Nodepool(Lister, BaseClient):
             resources_pb2.Nodepool(
                 id=nodepool['id'],
                 compute_cluster=resources_pb2.ComputeCluster(
-                    id=nodepool['compute_cluster']['id'], user_id=self.user_app_id.user_id
+                    id=nodepool['compute_cluster']['id'],
+                    user_id=nodepool['compute_cluster']['user_id']
+                    if 'user_id' in nodepool['compute_cluster']
+                    else self.user_app_id.user_id,
                 ),
             )
             for nodepool in deployment['nodepools']

clarifai/client/pipeline.py

@@ -4,6 +4,7 @@ from typing import Dict, List
 
 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 clarifai.client.base import BaseClient
 from clarifai.client.lister import Lister
@@ -13,22 +14,6 @@ from clarifai.utils.constants import DEFAULT_BASE
 from clarifai.utils.logging import logger
 
 
-def _get_status_name(status_code: int) -> str:
-    """Get the human-readable name for a status code."""
-    status_mapping = {
-        # Job status codes (these are the actual values based on the error message showing 64001)
-        64001: "JOB_QUEUED",
-        64002: "JOB_RUNNING",
-        64003: "JOB_COMPLETED",
-        64004: "JOB_FAILED",
-        64005: "JOB_UNEXPECTED_ERROR",
-        # Standard status codes
-        10000: "SUCCESS",
-        10010: "MIXED_STATUS",
-    }
-    return status_mapping.get(status_code, f"UNKNOWN_STATUS_{status_code}")
-
-
 class Pipeline(Lister, BaseClient):
     """Pipeline is a class that provides access to Clarifai API endpoints related to Pipeline information."""
 
@@ -82,13 +67,17 @@ class Pipeline(Lister, BaseClient):
 
         self.pipeline_id = pipeline_id
         self.pipeline_version_id = pipeline_version_id
-        self.pipeline_version_run_id = pipeline_version_run_id or str(uuid.uuid4())
+        self.pipeline_version_run_id = pipeline_version_run_id or str(uuid.uuid4().hex)
         self.user_id = user_id
         self.app_id = app_id
         self.nodepool_id = nodepool_id
         self.compute_cluster_id = compute_cluster_id
         self.log_file = log_file
 
+        # Store all kwargs as attributes for API data
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+
         BaseClient.__init__(
             self,
             user_id=user_id,
@@ -152,9 +141,15 @@ class Pipeline(Lister, BaseClient):
         )
 
         if response.status.code != status_code_pb2.StatusCode.SUCCESS:
-            raise UserError(
-                f"Failed to start pipeline run: {response.status.description}. Details: {response.status.details}"
-            )
+            if response.status.code == status_code_pb2.StatusCode.CONN_DOES_NOT_EXIST:
+                logger.error(
+                    f"Pipeline {self.pipeline_id} does not exist, did you call 'clarifai pipeline upload' first? "
+                )
+                return json_format.MessageToDict(response, preserving_proto_field_name=True)
+            else:
+                raise UserError(
+                    f"Failed to start pipeline run: {response.status.description}. Details: {response.status.details}. Code: {status_code_pb2.StatusCode.Name(response.status.code)}."
+                )
 
         if not response.pipeline_version_runs:
             raise UserError("No pipeline version run was created")
@@ -218,6 +213,9 @@ class Pipeline(Lister, BaseClient):
                     continue
 
                 pipeline_run = run_response.pipeline_version_run
+                pipeline_run_dict = json_format.MessageToDict(
+                    pipeline_run, preserving_proto_field_name=True
+                )
 
                 # Display new log entries
                 self._display_new_logs(run_id, seen_logs)
@@ -233,7 +231,7 @@ class Pipeline(Lister, BaseClient):
                     orch_status = pipeline_run.orchestration_status
                     if hasattr(orch_status, 'status') and orch_status.status:
                         status_code = orch_status.status.code
-                        status_name = _get_status_name(status_code)
+                        status_name = status_code_pb2.StatusCode.Name(status_code)
                         logger.info(f"Pipeline run status: {status_code} ({status_name})")
 
                         # Display orchestration status details if available
@@ -241,23 +239,29 @@ class Pipeline(Lister, BaseClient):
                             logger.info(f"Orchestration status: {orch_status.description}")
 
                         # Success codes that allow continuation: JOB_RUNNING, JOB_QUEUED
-                        if status_code in [64001, 64002]:  # JOB_QUEUED, JOB_RUNNING
+                        if status_code in [
+                            status_code_pb2.JOB_QUEUED,
+                            status_code_pb2.JOB_RUNNING,
+                        ]:  # JOB_QUEUED, JOB_RUNNING
                             logger.info(f"Pipeline run in progress: {status_code} ({status_name})")
                             # Continue monitoring
                         # Successful terminal state: JOB_COMPLETED
-                        elif status_code == 64003:  # JOB_COMPLETED
+                        elif status_code == status_code_pb2.JOB_COMPLETED:  # JOB_COMPLETED
                             logger.info("Pipeline run completed successfully!")
-                            return {"status": "success", "pipeline_version_run": pipeline_run}
+                            return {"status": "success", "pipeline_version_run": pipeline_run_dict}
                         # Failure terminal states: JOB_UNEXPECTED_ERROR, JOB_FAILED
-                        elif status_code in [64004, 64005]:  # JOB_FAILED, JOB_UNEXPECTED_ERROR
+                        elif status_code in [
+                            status_code_pb2.JOB_FAILED,
+                            status_code_pb2.JOB_UNEXPECTED_ERROR,
+                        ]:  # JOB_FAILED, JOB_UNEXPECTED_ERROR
                             logger.error(
                                 f"Pipeline run failed with status: {status_code} ({status_name})"
                             )
-                            return {"status": "failed", "pipeline_version_run": pipeline_run}
+                            return {"status": "failed", "pipeline_version_run": pipeline_run_dict}
                         # Handle legacy SUCCESS status for backward compatibility
                         elif status_code == status_code_pb2.StatusCode.SUCCESS:
                             logger.info("Pipeline run completed successfully!")
-                            return {"status": "success", "pipeline_version_run": pipeline_run}
+                            return {"status": "success", "pipeline_version_run": pipeline_run_dict}
                         elif status_code != status_code_pb2.StatusCode.MIXED_STATUS:
                             # Log other unexpected statuses but continue monitoring
                             logger.warning(

clarifai/client/pipeline_step.py

@@ -0,0 +1,72 @@
+from clarifai.client.base import BaseClient
+from clarifai.client.lister import Lister
+from clarifai.urls.helper import ClarifaiUrlHelper
+from clarifai.utils.constants import DEFAULT_BASE
+
+
+class PipelineStep(Lister, BaseClient):
+    """PipelineStep is a class that provides access to Clarifai API endpoints related to PipelineStep information."""
+
+    def __init__(
+        self,
+        url: str = None,
+        pipeline_step_id: str = None,
+        pipeline_step_version_id: str = None,
+        user_id: str = None,
+        app_id: str = None,
+        pipeline_id: str = None,
+        base_url: str = DEFAULT_BASE,
+        pat: str = None,
+        token: str = None,
+        root_certificates_path: str = None,
+        **kwargs,
+    ):
+        """Initializes a PipelineStep object.
+
+        Args:
+            url (str): The URL to initialize the pipeline step object.
+            pipeline_step_id (str): The PipelineStep ID for the PipelineStep to interact with.
+            pipeline_step_version_id (str): The PipelineStep version ID for the PipelineStep to interact with.
+            user_id (str): The User ID for the PipelineStep to interact with.
+            app_id (str): The App ID for the PipelineStep to interact with.
+            pipeline_id (str): The Pipeline ID for the PipelineStep to interact with.
+            base_url (str): Base API url. Default "https://api.clarifai.com"
+            pat (str): A personal access token for authentication.
+            token (str): A session token for authentication.
+            root_certificates_path (str): Path to the SSL root certificates file.
+            **kwargs: Additional keyword arguments to be passed to the BaseClient.
+        """
+        if url:
+            user_id, app_id, _, pipeline_step_id, pipeline_step_version_id = (
+                ClarifaiUrlHelper.split_clarifai_url(url)
+            )
+
+        # Store all kwargs as attributes for API data
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+
+        self.kwargs = {
+            "pipeline_step_id": pipeline_step_id,
+            "pipeline_step_version_id": pipeline_step_version_id,
+            "user_id": user_id,
+            "app_id": app_id,
+            "pipeline_id": pipeline_id,
+            **kwargs,
+        }
+
+        BaseClient.__init__(
+            self,
+            user_id=user_id,
+            app_id=app_id,
+            base=base_url,
+            pat=pat,
+            token=token,
+            root_certificates_path=root_certificates_path,
+        )
+        Lister.__init__(self)
+
+        self.pipeline_step_id = pipeline_step_id
+        self.pipeline_step_version_id = pipeline_step_version_id
+        self.pipeline_id = pipeline_id
+        self.user_id = user_id
+        self.app_id = app_id

clarifai/client/user.py

@@ -153,6 +153,80 @@ class User(Lister, BaseClient):
         for compute_cluster_info in all_compute_clusters_info:
             yield ComputeCluster.from_auth_helper(self.auth_helper, **compute_cluster_info)
 
+    def list_pipelines(
+        self, page_no: int = None, per_page: int = None
+    ) -> Generator[dict, None, None]:
+        """List all pipelines for the user across all apps
+
+        Args:
+            page_no (int): The page number to list.
+            per_page (int): The number of items per page.
+
+        Yields:
+            Dict: Dictionaries containing information about the pipelines.
+
+        Example:
+            >>> from clarifai.client.user import User
+            >>> client = User(user_id="user_id")
+            >>> all_pipelines = list(client.list_pipelines())
+
+        Note:
+            Defaults to 16 per page if page_no is specified and per_page is not specified.
+            If both page_no and per_page are None, then lists all the resources.
+        """
+        request_data = dict(user_app_id=self.user_app_id)
+        all_pipelines_info = self.list_pages_generator(
+            self.STUB.ListPipelines,
+            service_pb2.ListPipelinesRequest,
+            request_data,
+            per_page=per_page,
+            page_no=page_no,
+        )
+
+        for pipeline_info in all_pipelines_info:
+            pipeline = App._process_pipeline_info(
+                pipeline_info, self.auth_helper, only_in_app=False
+            )
+            if pipeline is not None:
+                yield pipeline
+
+    def list_pipeline_steps(
+        self, page_no: int = None, per_page: int = None
+    ) -> Generator[dict, None, None]:
+        """List all pipeline steps for the user across all apps
+
+        Args:
+            page_no (int): The page number to list.
+            per_page (int): The number of items per page.
+
+        Yields:
+            Dict: Dictionaries containing information about the pipeline steps.
+
+        Example:
+            >>> from clarifai.client.user import User
+            >>> client = User(user_id="user_id")
+            >>> all_pipeline_steps = list(client.list_pipeline_steps())
+
+        Note:
+            Defaults to 16 per page if page_no is specified and per_page is not specified.
+            If both page_no and per_page are None, then lists all the resources.
+        """
+        request_data = dict(user_app_id=self.user_app_id)
+        all_pipeline_steps_info = self.list_pages_generator(
+            self.STUB.ListPipelineStepVersions,
+            service_pb2.ListPipelineStepVersionsRequest,
+            request_data,
+            per_page=per_page,
+            page_no=page_no,
+        )
+
+        for pipeline_step_info in all_pipeline_steps_info:
+            pipeline_step = App._process_pipeline_step_info(
+                pipeline_step_info, self.auth_helper, only_in_app=False
+            )
+            if pipeline_step is not None:
+                yield pipeline_step
+
     def create_app(self, app_id: str, base_workflow: str = 'Empty', **kwargs) -> App:
         """Creates an app for the user.
 

clarifai/runners/pipelines/pipeline_builder.py

@@ -86,7 +86,7 @@ class PipelineBuilder:
 
         if not step_directories:
             logger.info("No pipeline steps to upload (step_directories is empty)")
-            return True
+            return False  # treat this as an error.
 
         logger.info(f"Uploading {len(step_directories)} pipeline steps...")
 
@@ -191,25 +191,38 @@ class PipelineBuilder:
                         if "templateRef" in step:
                             template_ref = step["templateRef"]
                             name = template_ref["name"]
+                            # Extract step name
+                            parts = name.split('/')
 
                             # 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
+                                # The step name should match the directory name or be derivable from it
+                                version_id = self.uploaded_step_versions.get(step_name, None)
+                                if version_id is not None:
+                                    # 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}")
+                            elif self.validator.TEMPLATE_REF_WITH_VERSION_PATTERN.match(name):
+                                # strip the /versions/{version_id} from the end of name
+                                # to get the name like above
+                                orig_name = name
+                                name = orig_name.rsplit('/versions/', 1)[0]
+                                step_name = parts[-3]  # Get the step name from the path
+
+                                # if it already has a version, make sure it matches the uploaded
+                                # version
+                                version_id = self.uploaded_step_versions.get(step_name, None)
+                                if version_id is not None:
+                                    # 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 {orig_name} to {new_name}"
+                                    )
 
     def create_pipeline(self) -> bool:
         """Create the pipeline using PostPipelines RPC."""

clarifai/runners/server.py

@@ -92,6 +92,7 @@ def serve(
     runner_id: str = os.environ.get("CLARIFAI_RUNNER_ID", None),
     base_url: str = os.environ.get("CLARIFAI_API_BASE", "https://api.clarifai.com"),
     pat: str = os.environ.get("CLARIFAI_PAT", None),
+    context=None,  # This is the current context object that contains user_id, app_id, model_id, etc.
 ):
     builder = ModelBuilder(model_path, download_validation_only=True)
 
@@ -133,7 +134,35 @@ def serve(
             pat=pat,
             num_parallel_polls=num_threads,
         )
-        logger.info("Runner started successfully and is waiting for work from the API...\n")
+
+        if context is None:
+            logger.debug("Context is None. Skipping code snippet generation.")
+        else:
+            method_signatures = builder.get_method_signatures(mocking=False)
+            from clarifai.runners.utils import code_script
+
+            snippet = code_script.generate_client_script(
+                method_signatures,
+                user_id=context.user_id,
+                app_id=context.app_id,
+                model_id=context.model_id,
+                deployment_id=context.deployment_id,
+                base_url=context.api_base,
+            )
+            logger.info(
+                "✅ Your model is running locally and is ready for requests from the API...\n"
+            )
+            logger.info(
+                f"> Code Snippet: To call your model via the API, use this code snippet:\n{snippet}"
+            )
+            logger.info(
+                f"> Playground:   To chat with your model, visit: {context.ui}/playground?model={context.model_id}__{context.model_version_id}&user_id={context.user_id}&app_id={context.app_id}\n"
+            )
+            logger.info(
+                f"> API URL:      To call your model via the API, use this model URL: {context.ui}/users/{context.user_id}/apps/{context.app_id}/models/{context.model_id}\n"
+            )
+            logger.info("Press CTRL+C to stop the runner.\n")
+
         runner.start()  # start the runner to fetch work from the API.
 
 

clarifai/runners/utils/code_script.py

@@ -112,7 +112,9 @@ print(response)
         deployment_id = None
     else:
         deployment_id = (
-            'os.environ["CLARIFAI_DEPLOYMENT_ID"]' if not deployment_id else repr(deployment_id)
+            'os.environ.get("CLARIFAI_DEPLOYMENT_ID", None)'
+            if not deployment_id
+            else repr(deployment_id)
         )
 
     deployment_line = (

clarifai/runners/utils/model_utils.py

@@ -68,13 +68,13 @@ def kill_process_tree(parent_pid, include_parent: bool = True, skip_pid: int = N
             logger.warning(f"Failed to kill parent process {parent_pid}: {e}")
 
 
-def execute_shell_command(
-    command: str,
-) -> subprocess.Popen:
+def execute_shell_command(command: str, stdout=None, stderr=subprocess.STDOUT) -> subprocess.Popen:
     """Execute a shell command and return its process handle.
 
     Args:
         command (str): The shell command to execute.
+        stdout : Verbose logging control,
+        stderr : Verbose error logging control
 
     Returns:
         subprocess.Popen: Process handle for the executed command.
@@ -90,7 +90,7 @@ def execute_shell_command(
     parts = shlex.split(command)
 
     try:
-        process = subprocess.Popen(parts, text=True, stderr=subprocess.STDOUT)
+        process = subprocess.Popen(parts, text=True, stdout=stdout, stderr=stderr)
 
         return process
     except subprocess.SubprocessError as e:

clarifai/runners/utils/pipeline_validation.py

@@ -11,10 +11,10 @@ class PipelineConfigValidator:
 
     # Regex patterns for templateRef validation
     TEMPLATE_REF_WITH_VERSION_PATTERN = re.compile(
-        r'^users/([^/]+)/apps/([^/]+)/pipeline-steps/([^/]+)/versions/([^/]+)$'
+        r'^users/([^/]+)/apps/([^/]+)/pipeline_steps/([^/]+)/versions/([^/]+)$'
     )
     TEMPLATE_REF_WITHOUT_VERSION_PATTERN = re.compile(
-        r'^users/([^/]+)/apps/([^/]+)/pipeline-steps/([^/]+)$'
+        r'^users/([^/]+)/apps/([^/]+)/pipeline_steps/([^/]+)$'
     )
 
     @classmethod
@@ -120,8 +120,8 @@ class PipelineConfigValidator:
         ):
             raise ValueError(
                 f"templateRef name '{name}' must match either pattern:\n"
-                f"  - users/{{user_id}}/apps/{{app_id}}/pipeline-steps/{{step_id}}\n"
-                f"  - users/{{user_id}}/apps/{{app_id}}/pipeline-steps/{{step_id}}/versions/{{version_id}}"
+                f"  - users/{{user_id}}/apps/{{app_id}}/pipeline_steps/{{step_id}}\n"
+                f"  - users/{{user_id}}/apps/{{app_id}}/pipeline_steps/{{step_id}}/versions/{{version_id}}"
             )
 
     @classmethod