clarifai 11.5.6__py3-none-any.whl → 11.6.1__py3-none-any.whl

clarifai/__init__.py

@@ -1 +1 @@
-__version__ = "11.5.6"
+__version__ = "11.6.1"

clarifai/cli/base.py

@@ -6,6 +6,7 @@ import sys
 import click
 import yaml
 
+from clarifai import __version__
 from clarifai.utils.cli import AliasedGroup, TableFormatter, load_command_modules
 from clarifai.utils.config import Config, Context
 from clarifai.utils.constants import DEFAULT_BASE, DEFAULT_CONFIG, DEFAULT_UI
@@ -14,6 +15,7 @@ from clarifai.utils.logging import logger
 
 # @click.group(cls=CustomMultiGroup)
 @click.group(cls=AliasedGroup)
+@click.version_option(version=__version__)
 @click.option('--config', default=DEFAULT_CONFIG)
 @click.pass_context
 def cli(ctx, config):

clarifai/cli/model.py

@@ -1,5 +1,6 @@
 import os
 import shutil
+import tempfile
 
 import click
 
@@ -16,13 +17,19 @@ from clarifai.utils.constants import (
     DEFAULT_LOCAL_DEV_NODEPOOL_ID,
 )
 from clarifai.utils.logging import logger
+from clarifai.utils.misc import (
+    clone_github_repo,
+    format_github_repo_url,
+)
 
 
 @cli.group(
     ['model'], context_settings={'max_content_width': shutil.get_terminal_size().columns - 10}
 )
 def model():
-    """Manage models: upload, test, local dev, predict, etc"""
+    """Manage & Develop Models: init, download-checkpoints, signatures, upload\n
+    Run & Test Models Locally: local-runner, local-grpc, local-test\n
+    Model Inference: list, predict"""
 
 
 @model.command()
@@ -38,7 +45,22 @@ def model():
     required=False,
     help='Model type: "mcp" for MCPModelClass, "openai" for OpenAIModelClass, or leave empty for default ModelClass.',
 )
-def init(model_path, model_type_id):
+@click.option(
+    '--github-pat',
+    required=False,
+    help='GitHub Personal Access Token for authentication when cloning private repositories.',
+)
+@click.option(
+    '--github-repo',
+    required=False,
+    help='GitHub repository URL or "user/repo" format to clone a repository from. If provided, the entire repository contents will be copied to the target directory instead of using default templates.',
+)
+@click.option(
+    '--branch',
+    required=False,
+    help='Git branch to clone from the GitHub repository. If not specified, the default branch will be used.',
+)
+def init(model_path, model_type_id, github_pat, github_repo, branch):
     """Initialize a new model directory structure.
 
     Creates the following structure in the specified directory:
@@ -47,65 +69,113 @@ def init(model_path, model_type_id):
     ├── requirements.txt
     └── config.yaml
 
+    If --github-repo is provided, the entire repository contents will be copied to the target
+    directory instead of using default templates. The --github-pat option can be used for authentication
+    when cloning private repositories. The --branch option can be used to specify a specific
+    branch to clone from.
+
     MODEL_PATH: Path where to create the model directory structure. If not specified, the current directory is used by default.
     """
-    from clarifai.cli.templates.model_templates import (
-        get_config_template,
-        get_model_template,
-        get_requirements_template,
-    )
-
     # Resolve the absolute path
     model_path = os.path.abspath(model_path)
 
     # Create the model directory if it doesn't exist
     os.makedirs(model_path, exist_ok=True)
 
-    # Create the 1/ subdirectory
-    model_version_dir = os.path.join(model_path, "1")
-    os.makedirs(model_version_dir, exist_ok=True)
-
-    # Create model.py
-    model_py_path = os.path.join(model_version_dir, "model.py")
-    if os.path.exists(model_py_path):
-        logger.warning(f"File {model_py_path} already exists, skipping...")
-    else:
-        model_template = get_model_template(model_type_id)
-        with open(model_py_path, 'w') as f:
-            f.write(model_template)
-        logger.info(f"Created {model_py_path}")
-
-    # Create requirements.txt
-    requirements_path = os.path.join(model_path, "requirements.txt")
-    if os.path.exists(requirements_path):
-        logger.warning(f"File {requirements_path} already exists, skipping...")
-    else:
-        requirements_template = get_requirements_template(model_type_id)
-        with open(requirements_path, 'w') as f:
-            f.write(requirements_template)
-        logger.info(f"Created {requirements_path}")
-
-    # Create config.yaml
-    config_path = os.path.join(model_path, "config.yaml")
-    if os.path.exists(config_path):
-        logger.warning(f"File {config_path} already exists, skipping...")
-    else:
-        config_model_type_id = "text-to-text"  # default
-
-        config_template = get_config_template(config_model_type_id)
-        with open(config_path, 'w') as f:
-            f.write(config_template)
-        logger.info(f"Created {config_path}")
-
-    logger.info(f"Model initialization complete in {model_path}")
-    logger.info("Next steps:")
-    logger.info("1. Search for '# TODO: please fill in' comments in the generated files")
-    logger.info("2. Update the model configuration in config.yaml")
-    logger.info("3. Add your model dependencies to requirements.txt")
-    logger.info("4. Implement your model logic in 1/model.py")
-
+    # Handle GitHub repository cloning if provided
+    if github_repo:
+        logger.info(f"Initializing model from GitHub repository: {github_repo}")
+
+        # Check if it's a local path or normalize the GitHub repo URL
+        if os.path.exists(github_repo):
+            repo_url = github_repo
+        else:
+            repo_url = format_github_repo_url(github_repo)
+
+        # Create a temporary directory for cloning
+        with tempfile.TemporaryDirectory() as temp_dir:
+            clone_dir = os.path.join(temp_dir, "repo")
+
+            # Clone the repository
+            if not clone_github_repo(repo_url, clone_dir, github_pat, branch):
+                logger.error(
+                    "Failed to clone repository. Falling back to template-based initialization."
+                )
+                github_repo = None  # Fall back to template mode
+            else:
+                # Copy the entire repository content to target directory (excluding .git)
+                for item in os.listdir(clone_dir):
+                    if item == '.git':
+                        continue
+
+                    source_path = os.path.join(clone_dir, item)
+                    target_path = os.path.join(model_path, item)
+
+                    if os.path.isdir(source_path):
+                        shutil.copytree(source_path, target_path, dirs_exist_ok=True)
+                    else:
+                        shutil.copy2(source_path, target_path)
+
+                logger.info("Model initialization complete with GitHub repository")
+                logger.info("Next steps:")
+                logger.info("1. Review the model configuration")
+                logger.info("2. Install any required dependencies manually")
+                logger.info("3. Test the model locally using 'clarifai model local-test'")
+                return
+
+    # Fall back to template-based initialization if no GitHub repo or if GitHub repo failed
+    if not github_repo:
+        from clarifai.cli.templates.model_templates import (
+            get_config_template,
+            get_model_template,
+            get_requirements_template,
+        )
 
-@model.command()
+        # Create the 1/ subdirectory
+        model_version_dir = os.path.join(model_path, "1")
+        os.makedirs(model_version_dir, exist_ok=True)
+
+        # Create model.py
+        model_py_path = os.path.join(model_version_dir, "model.py")
+        if os.path.exists(model_py_path):
+            logger.warning(f"File {model_py_path} already exists, skipping...")
+        else:
+            model_template = get_model_template(model_type_id)
+            with open(model_py_path, 'w') as f:
+                f.write(model_template)
+            logger.info(f"Created {model_py_path}")
+
+        # Create requirements.txt
+        requirements_path = os.path.join(model_path, "requirements.txt")
+        if os.path.exists(requirements_path):
+            logger.warning(f"File {requirements_path} already exists, skipping...")
+        else:
+            requirements_template = get_requirements_template(model_type_id)
+            with open(requirements_path, 'w') as f:
+                f.write(requirements_template)
+            logger.info(f"Created {requirements_path}")
+
+        # Create config.yaml
+        config_path = os.path.join(model_path, "config.yaml")
+        if os.path.exists(config_path):
+            logger.warning(f"File {config_path} already exists, skipping...")
+        else:
+            config_model_type_id = "text-to-text"  # default
+
+            config_template = get_config_template(config_model_type_id)
+            with open(config_path, 'w') as f:
+                f.write(config_template)
+            logger.info(f"Created {config_path}")
+
+        logger.info(f"Model initialization complete in {model_path}")
+        logger.info("Next steps:")
+        logger.info("1. Search for '# TODO: please fill in' comments in the generated files")
+        logger.info("2. Update the model configuration in config.yaml")
+        logger.info("3. Add your model dependencies to requirements.txt")
+        logger.info("4. Implement your model logic in 1/model.py")
+
+
+@model.command(help="Upload a trained model.")
 @click.argument("model_path", type=click.Path(exists=True), required=False, default=".")
 @click.option(
     '--stage',
@@ -120,17 +190,25 @@ def init(model_path, model_type_id):
     is_flag=True,
     help='Flag to skip generating a dockerfile so that you can manually edit an already created dockerfile.',
 )
-def upload(model_path, stage, skip_dockerfile):
+@click.pass_context
+def upload(ctx, model_path, stage, skip_dockerfile):
     """Upload a model to Clarifai.
 
     MODEL_PATH: Path to the model directory. If not specified, the current directory is used by default.
     """
     from clarifai.runners.models.model_builder import upload_model
 
-    upload_model(model_path, stage, skip_dockerfile)
+    validate_context(ctx)
+    upload_model(
+        model_path,
+        stage,
+        skip_dockerfile,
+        pat=ctx.obj.current.pat,
+        base_url=ctx.obj.current.api_base,
+    )
 
 
-@model.command()
+@model.command(help="Download model checkpoint files.")
 @click.argument(
     "model_path",
     type=click.Path(exists=True),
@@ -164,7 +242,7 @@ def download_checkpoints(model_path, out_path, stage):
     builder.download_checkpoints(stage=stage, checkpoint_path_override=out_path)
 
 
-@model.command()
+@model.command(help="Generate model method signatures.")
 @click.argument(
     "model_path",
     type=click.Path(exists=True),
@@ -195,7 +273,7 @@ def signatures(model_path, out_path):
         click.echo(signatures)
 
 
-@model.command()
+@model.command(name="local-test", help="Execute all model unit tests locally.")
 @click.argument(
     "model_path",
     type=click.Path(exists=True),
@@ -254,7 +332,7 @@ def test_locally(model_path, keep_env=False, keep_image=False, mode='env', skip_
         click.echo(f"Failed to test model locally: {e}", err=True)
 
 
-@model.command()
+@model.command(name="local-grpc", help="Run the model locally via a gRPC server.")
 @click.argument(
     "model_path",
     type=click.Path(exists=True),
@@ -322,7 +400,7 @@ def run_locally(model_path, port, mode, keep_env, keep_image, skip_dockerfile=Fa
         click.echo(f"Failed to starts model server locally: {e}", err=True)
 
 
-@model.command()
+@model.command(name="local-runner", help="Run the model locally for dev, debug, or local compute.")
 @click.argument(
     "model_path",
     type=click.Path(exists=True),
@@ -486,7 +564,13 @@ def local_dev(ctx, model_path):
         )
         if y.lower() != 'y':
             raise click.Abort()
-        model = app.create_model(model_id, model_type_id=DEFAULT_LOCAL_DEV_MODEL_TYPE)
+        try:
+            model_type_id = ctx.obj.current.model_type_id
+        except AttributeError:
+            model_type_id = DEFAULT_LOCAL_DEV_MODEL_TYPE
+
+        model = app.create_model(model_id, model_type_id=model_type_id)
+        ctx.obj.current.CLARIFAI_MODEL_TYPE_ID = model_type_id
         ctx.obj.current.CLARIFAI_MODEL_ID = model_id
         ctx.obj.to_yaml()  # save to yaml file.
 
@@ -605,6 +689,7 @@ def local_dev(ctx, model_path):
             f"config.yaml not found in {model_path}. Please ensure you are passing the correct directory."
         )
     config = ModelBuilder._load_config(config_file)
+    model_type_id = config.get('model', {}).get('model_type_id', DEFAULT_LOCAL_DEV_MODEL_TYPE)
     # The config.yaml doens't match what we created above.
     if 'model' in config and model_id != config['model'].get('id'):
         logger.info(f"Current model section of config.yaml: {config.get('model', {})}")
@@ -614,7 +699,7 @@ def local_dev(ctx, model_path):
         if y.lower() != 'y':
             raise click.Abort()
         config = ModelBuilder._set_local_dev_model(
-            config, user_id, app_id, model_id, DEFAULT_LOCAL_DEV_MODEL_TYPE
+            config, user_id, app_id, model_id, model_type_id
         )
         ModelBuilder._backup_config(config_file)
         ModelBuilder._save_config(config_file, config)
@@ -655,7 +740,7 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
     )
 
 
-@model.command()
+@model.command(help="Perform a prediction using the model.")
 @click.option(
     '--config',
     type=click.Path(exists=True),
@@ -837,7 +922,7 @@ def predict(
 )
 @click.pass_context
 def list_model(ctx, user_id, app_id):
-    """List models of user/community
+    """List models of user/community.
 
     USER_ID: User id. If not specified, the current user is used by default. Set "all" to get all public models in Clarifai platform.
     """

clarifai/cli/pipeline.py

@@ -27,6 +27,146 @@ def upload(path):
     upload_pipeline(path)
 
 
+@pipeline.command()
+@click.option(
+    '--config',
+    type=click.Path(exists=True),
+    required=False,
+    help='Path to the pipeline run config file.',
+)
+@click.option('--pipeline_id', required=False, help='Pipeline ID to run.')
+@click.option('--pipeline_version_id', required=False, help='Pipeline Version ID to run.')
+@click.option(
+    '--pipeline_version_run_id',
+    required=False,
+    help='Pipeline Version Run ID. If not provided, a UUID will be generated.',
+)
+@click.option('--user_id', required=False, help='User ID of the pipeline.')
+@click.option('--app_id', required=False, help='App ID that contains the pipeline.')
+@click.option('--nodepool_id', required=False, help='Nodepool ID to run the pipeline on.')
+@click.option(
+    '--compute_cluster_id', required=False, help='Compute Cluster ID to run the pipeline on.'
+)
+@click.option('--pipeline_url', required=False, help='Pipeline URL to run.')
+@click.option(
+    '--timeout',
+    type=int,
+    default=3600,
+    help='Maximum time to wait for completion in seconds. Default 3600 (1 hour).',
+)
+@click.option(
+    '--monitor_interval',
+    type=int,
+    default=10,
+    help='Interval between status checks in seconds. Default 10.',
+)
+@click.option(
+    '--log_file',
+    type=click.Path(),
+    required=False,
+    help='Path to file where logs should be written. If not provided, logs are displayed on console.',
+)
+@click.option(
+    '--monitor',
+    is_flag=True,
+    default=False,
+    help='Monitor an existing pipeline run instead of starting a new one. Requires pipeline_version_run_id.',
+)
+@click.pass_context
+def run(
+    ctx,
+    config,
+    pipeline_id,
+    pipeline_version_id,
+    pipeline_version_run_id,
+    user_id,
+    app_id,
+    nodepool_id,
+    compute_cluster_id,
+    pipeline_url,
+    timeout,
+    monitor_interval,
+    log_file,
+    monitor,
+):
+    """Run a pipeline and monitor its progress."""
+    import json
+
+    from clarifai.client.pipeline import Pipeline
+    from clarifai.utils.cli import from_yaml, validate_context
+
+    validate_context(ctx)
+
+    if config:
+        config_data = from_yaml(config)
+        pipeline_id = config_data.get('pipeline_id', pipeline_id)
+        pipeline_version_id = config_data.get('pipeline_version_id', pipeline_version_id)
+        pipeline_version_run_id = config_data.get(
+            'pipeline_version_run_id', pipeline_version_run_id
+        )
+        user_id = config_data.get('user_id', user_id)
+        app_id = config_data.get('app_id', app_id)
+        nodepool_id = config_data.get('nodepool_id', nodepool_id)
+        compute_cluster_id = config_data.get('compute_cluster_id', compute_cluster_id)
+        pipeline_url = config_data.get('pipeline_url', pipeline_url)
+        timeout = config_data.get('timeout', timeout)
+        monitor_interval = config_data.get('monitor_interval', monitor_interval)
+        log_file = config_data.get('log_file', log_file)
+        monitor = config_data.get('monitor', monitor)
+
+    # compute_cluster_id and nodepool_id are mandatory regardless of whether pipeline_url is provided
+    if not compute_cluster_id or not nodepool_id:
+        raise ValueError("--compute_cluster_id and --nodepool_id are mandatory parameters.")
+
+    # When monitor flag is used, pipeline_version_run_id is mandatory
+    if monitor and not pipeline_version_run_id:
+        raise ValueError("--pipeline_version_run_id is required when using --monitor flag.")
+
+    if pipeline_url:
+        # When using pipeline_url, other parameters are optional (will be parsed from URL)
+        required_params_provided = True
+    else:
+        # When not using pipeline_url, all individual parameters are required
+        required_params_provided = all([pipeline_id, user_id, app_id, pipeline_version_id])
+
+    if not required_params_provided:
+        raise ValueError(
+            "Either --user_id & --app_id & --pipeline_id & --pipeline_version_id or --pipeline_url must be provided."
+        )
+
+    if pipeline_url:
+        pipeline = Pipeline(
+            url=pipeline_url,
+            pat=ctx.obj.current.pat,
+            base_url=ctx.obj.current.api_base,
+            pipeline_version_run_id=pipeline_version_run_id,
+            nodepool_id=nodepool_id,
+            compute_cluster_id=compute_cluster_id,
+            log_file=log_file,
+        )
+    else:
+        pipeline = Pipeline(
+            pipeline_id=pipeline_id,
+            pipeline_version_id=pipeline_version_id,
+            pipeline_version_run_id=pipeline_version_run_id,
+            user_id=user_id,
+            app_id=app_id,
+            nodepool_id=nodepool_id,
+            compute_cluster_id=compute_cluster_id,
+            pat=ctx.obj.current.pat,
+            base_url=ctx.obj.current.api_base,
+            log_file=log_file,
+        )
+
+    if monitor:
+        # Monitor existing pipeline run instead of starting new one
+        result = pipeline.monitor_only(timeout=timeout, monitor_interval=monitor_interval)
+    else:
+        # Start new pipeline run and monitor it
+        result = pipeline.run(timeout=timeout, monitor_interval=monitor_interval)
+    click.echo(json.dumps(result, indent=2, default=str))
+
+
 @pipeline.command()
 @click.argument(
     "pipeline_path",

clarifai/cli/pipeline_step.py

@@ -8,7 +8,7 @@ from clarifai.utils.logging import logger
 
 
 @cli.group(
-    ['pipelinestep'],
+    ['pipelinestep', 'ps'],
     context_settings={'max_content_width': shutil.get_terminal_size().columns - 10},
 )
 def pipeline_step():

clarifai/client/__init__.py

@@ -7,6 +7,7 @@ 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.search import Search
 from clarifai.client.user import User
 from clarifai.client.workflow import Workflow
@@ -18,6 +19,7 @@ __all__ = [
     'App',
     'Model',
     'Workflow',
+    'Pipeline',
     'Module',
     'Lister',
     'Dataset',

clarifai/client/model.py

@@ -66,6 +66,7 @@ class Model(Lister, BaseClient):
         compute_cluster_id: str = None,
         nodepool_id: str = None,
         deployment_id: str = None,
+        deployment_user_id: str = None,
         **kwargs,
     ):
         """Initializes a Model object.
@@ -78,6 +79,10 @@ class Model(Lister, BaseClient):
             pat (str): A personal access token for authentication. Can be set as env var CLARIFAI_PAT
             token (str): A session token for authentication. Accepts either a session token or a pat. Can be set as env var CLARIFAI_SESSION_TOKEN
             root_certificates_path (str): Path to the SSL root certificates file, used to establish secure gRPC connections.
+            compute_cluster_id (str): Compute cluster ID for runner selector.
+            nodepool_id (str): Nodepool ID for runner selector.
+            deployment_id (str): Deployment ID for runner selector.
+            deployment_user_id (str): User ID to use for runner selector (organization or user). If not provided, defaults to PAT owner user_id.
             **kwargs: Additional keyword arguments to be passed to the Model.
         """
         if url and model_id:
@@ -115,10 +120,13 @@ class Model(Lister, BaseClient):
         )
         Lister.__init__(self)
 
+        self.deployment_user_id = deployment_user_id
+
         self._set_runner_selector(
             compute_cluster_id=compute_cluster_id,
             nodepool_id=nodepool_id,
             deployment_id=deployment_id,
+            deployment_user_id=deployment_user_id,
         )
 
     @classmethod
@@ -633,9 +641,13 @@ class Model(Lister, BaseClient):
         compute_cluster_id: str = None,
         nodepool_id: str = None,
         deployment_id: str = None,
+        deployment_user_id: str = None,
     ):
-        # Get UserID
-        if any([deployment_id, nodepool_id, compute_cluster_id]):
+        # Get UserID for runner selector
+        user_id = None
+        if deployment_user_id:
+            user_id = deployment_user_id
+        elif any([deployment_id, nodepool_id, compute_cluster_id]):
             from clarifai.client.user import User
 
             user_id = (
@@ -643,13 +655,11 @@ class Model(Lister, BaseClient):
                 .get_user_info(user_id='me')
                 .user.id
             )
-
         runner_selector = None
         if deployment_id and (compute_cluster_id or nodepool_id):
             raise UserError(
                 "You can only specify one of deployment_id or compute_cluster_id and nodepool_id."
             )
-
         if deployment_id:
             runner_selector = Deployment.get_runner_selector(
                 user_id=user_id, deployment_id=deployment_id
@@ -658,7 +668,6 @@ class Model(Lister, BaseClient):
             runner_selector = Nodepool.get_runner_selector(
                 user_id=user_id, compute_cluster_id=compute_cluster_id, nodepool_id=nodepool_id
             )
-
         # set the runner selector
         self._runner_selector = runner_selector
 

clarifai/client/pipeline.py

@@ -0,0 +1,312 @@
+import time
+import uuid
+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 clarifai.client.base import BaseClient
+from clarifai.client.lister import Lister
+from clarifai.errors import UserError
+from clarifai.urls.helper import ClarifaiUrlHelper
+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."""
+
+    def __init__(
+        self,
+        url: str = None,
+        pipeline_id: str = None,
+        pipeline_version_id: str = None,
+        pipeline_version_run_id: str = None,
+        user_id: str = None,
+        app_id: str = None,
+        nodepool_id: str = None,
+        compute_cluster_id: str = None,
+        log_file: str = None,
+        base_url: str = DEFAULT_BASE,
+        pat: str = None,
+        token: str = None,
+        root_certificates_path: str = None,
+        **kwargs,
+    ):
+        """Initializes a Pipeline object.
+
+        Args:
+            url (str): The URL to initialize the pipeline object.
+            pipeline_id (str): The Pipeline ID to interact with.
+            pipeline_version_id (str): The Pipeline Version ID to interact with.
+            pipeline_version_run_id (str): The Pipeline Version Run ID. If not provided, a UUID will be generated.
+            user_id (str): The User ID that owns the pipeline.
+            app_id (str): The App ID that contains the pipeline.
+            nodepool_id (str): The Nodepool ID to run the pipeline on.
+            compute_cluster_id (str): The Compute Cluster ID to run the pipeline on.
+            log_file (str): Path to file where logs should be written. If not provided, logs are displayed on console.
+            base_url (str): Base API url. Default "https://api.clarifai.com"
+            pat (str): A personal access token for authentication. Can be set as env var CLARIFAI_PAT
+            token (str): A session token for authentication. Accepts either a session token or a pat. Can be set as env var CLARIFAI_SESSION_TOKEN
+            root_certificates_path (str): Path to the SSL root certificates file, used to establish secure gRPC connections.
+            **kwargs: Additional keyword arguments to be passed to the Pipeline.
+        """
+        if url and pipeline_id:
+            raise UserError("You can only specify one of url or pipeline_id.")
+        if not url and not pipeline_id:
+            raise UserError("You must specify one of url or pipeline_id.")
+        if url:
+            parsed_user_id, parsed_app_id, _, parsed_pipeline_id, parsed_version_id = (
+                ClarifaiUrlHelper.split_clarifai_url(url)
+            )
+            user_id = user_id or parsed_user_id
+            app_id = app_id or parsed_app_id
+            pipeline_id = parsed_pipeline_id
+            pipeline_version_id = pipeline_version_id or parsed_version_id
+
+        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.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
+
+        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)
+
+        # Set up runner selector if compute cluster and nodepool are provided
+        self._runner_selector = None
+        if self.compute_cluster_id and self.nodepool_id:
+            from clarifai.client.nodepool import Nodepool
+
+            self._runner_selector = Nodepool.get_runner_selector(
+                user_id=self.user_id,
+                compute_cluster_id=self.compute_cluster_id,
+                nodepool_id=self.nodepool_id,
+            )
+
+    def run(self, inputs: List = None, timeout: int = 3600, monitor_interval: int = 10) -> Dict:
+        """Run the pipeline and monitor its progress.
+
+        Args:
+            inputs (List): List of inputs to run the pipeline with. If None, runs without inputs.
+            timeout (int): Maximum time to wait for completion in seconds. Default 3600 (1 hour).
+            monitor_interval (int): Interval between status checks in seconds. Default 10.
+
+        Returns:
+            Dict: The pipeline run result.
+        """
+        # Create a new pipeline version run
+        pipeline_version_run = resources_pb2.PipelineVersionRun()
+        pipeline_version_run.id = self.pipeline_version_run_id
+
+        # Set nodepools if nodepool information is available
+        if self.nodepool_id and self.compute_cluster_id:
+            nodepool = resources_pb2.Nodepool(
+                id=self.nodepool_id,
+                compute_cluster=resources_pb2.ComputeCluster(
+                    id=self.compute_cluster_id, user_id=self.user_id
+                ),
+            )
+            pipeline_version_run.nodepools.extend([nodepool])
+
+        run_request = service_pb2.PostPipelineVersionRunsRequest()
+        run_request.user_app_id.CopyFrom(self.user_app_id)
+        run_request.pipeline_id = self.pipeline_id
+        run_request.pipeline_version_id = self.pipeline_version_id or ""
+        run_request.pipeline_version_runs.append(pipeline_version_run)
+
+        # Add runner selector if available
+        if self._runner_selector:
+            run_request.runner_selector.CopyFrom(self._runner_selector)
+
+        logger.info(f"Starting pipeline run for pipeline {self.pipeline_id}")
+        response = self.STUB.PostPipelineVersionRuns(
+            run_request, metadata=self.auth_helper.metadata
+        )
+
+        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 not response.pipeline_version_runs:
+            raise UserError("No pipeline version run was created")
+
+        pipeline_version_run = response.pipeline_version_runs[0]
+        run_id = pipeline_version_run.id or self.pipeline_version_run_id
+
+        logger.info(f"Pipeline version run created with ID: {run_id}")
+
+        # Monitor the run
+        return self._monitor_pipeline_run(run_id, timeout, monitor_interval)
+
+    def monitor_only(self, timeout: int = 3600, monitor_interval: int = 10) -> Dict:
+        """Monitor an existing pipeline run without starting a new one.
+
+        Args:
+            timeout (int): Maximum time to wait for completion in seconds. Default 3600 (1 hour).
+            monitor_interval (int): Interval between status checks in seconds. Default 10.
+
+        Returns:
+            Dict: The pipeline run result.
+        """
+        if not self.pipeline_version_run_id:
+            raise UserError("pipeline_version_run_id is required for monitoring existing runs")
+
+        logger.info(f"Monitoring existing pipeline run with ID: {self.pipeline_version_run_id}")
+
+        # Monitor the existing run
+        return self._monitor_pipeline_run(self.pipeline_version_run_id, timeout, monitor_interval)
+
+    def _monitor_pipeline_run(self, run_id: str, timeout: int, monitor_interval: int) -> Dict:
+        """Monitor a pipeline version run until completion.
+
+        Args:
+            run_id (str): The pipeline version run ID to monitor.
+            timeout (int): Maximum time to wait for completion in seconds.
+            monitor_interval (int): Interval between status checks in seconds.
+
+        Returns:
+            Dict: The pipeline run result.
+        """
+        start_time = time.time()
+        seen_logs = set()
+
+        while time.time() - start_time < timeout:
+            # Get run status
+            get_run_request = service_pb2.GetPipelineVersionRunRequest()
+            get_run_request.user_app_id.CopyFrom(self.user_app_id)
+            get_run_request.pipeline_id = self.pipeline_id
+            get_run_request.pipeline_version_id = self.pipeline_version_id or ""
+            get_run_request.pipeline_version_run_id = run_id
+
+            try:
+                run_response = self.STUB.GetPipelineVersionRun(
+                    get_run_request, metadata=self.auth_helper.metadata
+                )
+
+                if run_response.status.code != status_code_pb2.StatusCode.SUCCESS:
+                    logger.error(f"Error getting run status: {run_response.status.description}")
+                    time.sleep(monitor_interval)
+                    continue
+
+                pipeline_run = run_response.pipeline_version_run
+
+                # Display new log entries
+                self._display_new_logs(run_id, seen_logs)
+
+                elapsed_time = time.time() - start_time
+                logger.info(f"Pipeline run monitoring... (elapsed {elapsed_time:.1f}s)")
+
+                # Check if we have orchestration status
+                if (
+                    hasattr(pipeline_run, 'orchestration_status')
+                    and pipeline_run.orchestration_status
+                ):
+                    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)
+                        logger.info(f"Pipeline run status: {status_code} ({status_name})")
+
+                        # Display orchestration status details if available
+                        if hasattr(orch_status, 'description') and orch_status.description:
+                            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
+                            logger.info(f"Pipeline run in progress: {status_code} ({status_name})")
+                            # Continue monitoring
+                        # Successful terminal state: JOB_COMPLETED
+                        elif status_code == 64003:  # JOB_COMPLETED
+                            logger.info("Pipeline run completed successfully!")
+                            return {"status": "success", "pipeline_version_run": pipeline_run}
+                        # Failure terminal states: JOB_UNEXPECTED_ERROR, JOB_FAILED
+                        elif status_code in [64004, 64005]:  # 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}
+                        # 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}
+                        elif status_code != status_code_pb2.StatusCode.MIXED_STATUS:
+                            # Log other unexpected statuses but continue monitoring
+                            logger.warning(
+                                f"Unexpected pipeline run status: {status_code} ({status_name}). Continuing to monitor..."
+                            )
+
+            except Exception as e:
+                logger.error(f"Error monitoring pipeline run: {e}")
+
+            time.sleep(monitor_interval)
+
+        logger.error(f"Pipeline run timed out after {timeout} seconds")
+        return {"status": "timeout"}
+
+    def _display_new_logs(self, run_id: str, seen_logs: set):
+        """Display new log entries for a pipeline version run.
+
+        Args:
+            run_id (str): The pipeline version run ID.
+            seen_logs (set): Set of already seen log entry IDs.
+        """
+        try:
+            logs_request = service_pb2.ListLogEntriesRequest()
+            logs_request.user_app_id.CopyFrom(self.user_app_id)
+            logs_request.pipeline_id = self.pipeline_id
+            logs_request.pipeline_version_id = self.pipeline_version_id or ""
+            logs_request.pipeline_version_run_id = run_id
+            logs_request.log_type = "pipeline.version.run"  # Set required log type
+            logs_request.page = 1
+            logs_request.per_page = 50
+
+            logs_response = self.STUB.ListLogEntries(
+                logs_request, metadata=self.auth_helper.metadata
+            )
+
+            if logs_response.status.code == status_code_pb2.StatusCode.SUCCESS:
+                for log_entry in logs_response.log_entries:
+                    # Use log entry URL or timestamp as unique identifier
+                    log_id = log_entry.url or f"{log_entry.created_at.seconds}_{log_entry.message}"
+                    if log_id not in seen_logs:
+                        seen_logs.add(log_id)
+                        log_message = f"[LOG] {log_entry.message.strip()}"
+
+                        # Write to file if log_file is specified, otherwise log to console
+                        if self.log_file:
+                            with open(self.log_file, 'a', encoding='utf-8') as f:
+                                f.write(log_message + '\n')
+                        else:
+                            logger.info(log_message)
+
+        except Exception as e:
+            logger.debug(f"Error fetching logs: {e}")

clarifai/runners/models/model_builder.py

@@ -73,6 +73,8 @@ class ModelBuilder:
         validate_api_ids: bool = True,
         download_validation_only: bool = False,
         app_not_found_action: Literal["auto_create", "prompt", "error"] = "error",
+        pat: str = None,
+        base_url: str = None,
     ):
         """
         :param folder: The folder containing the model.py, config.yaml, requirements.txt and
@@ -83,12 +85,16 @@ class ModelBuilder:
         just downloading a checkpoint.
         :param app_not_found_action: Defines how to handle the case when the app is not found.
         Options: 'auto_create' - create automatically, 'prompt' - ask user, 'error' - raise exception.
+        :param pat: Personal access token for authentication. If None, will use environment variables.
+        :param base_url: Base URL for the API. If None, will use environment variables.
         """
         assert app_not_found_action in ["auto_create", "prompt", "error"], ValueError(
             f"Expected one of {['auto_create', 'prompt', 'error']}, got {app_not_found_action=}"
         )
         self.app_not_found_action = app_not_found_action
         self._client = None
+        self._pat = pat
+        self._base_url = base_url
         if not validate_api_ids:  # for backwards compatibility
             download_validation_only = True
         self.download_validation_only = download_validation_only
@@ -487,8 +493,20 @@ class ModelBuilder:
             user_id = model.get('user_id')
             app_id = model.get('app_id')
 
-            self._base_api = os.environ.get('CLARIFAI_API_BASE', 'https://api.clarifai.com')
-            self._client = BaseClient(user_id=user_id, app_id=app_id, base=self._base_api)
+            # Use context parameters if provided, otherwise fall back to environment variables
+            self._base_api = (
+                self._base_url
+                if self._base_url
+                else os.environ.get('CLARIFAI_API_BASE', 'https://api.clarifai.com')
+            )
+
+            # Create BaseClient with explicit pat parameter if provided
+            if self._pat:
+                self._client = BaseClient(
+                    user_id=user_id, app_id=app_id, base=self._base_api, pat=self._pat
+                )
+            else:
+                self._client = BaseClient(user_id=user_id, app_id=app_id, base=self._base_api)
 
         return self._client
 
@@ -1226,15 +1244,17 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
                 return False
 
 
-def upload_model(folder, stage, skip_dockerfile):
+def upload_model(folder, stage, skip_dockerfile, pat=None, base_url=None):
     """
     Uploads a model to Clarifai.
 
     :param folder: The folder containing the model files.
     :param stage: The stage we are calling download checkpoints from. Typically this would "upload" and will download checkpoints if config.yaml checkpoints section has when set to "upload". Other options include "runtime" to be used in load_model or "upload" to be used during model upload. Set this stage to whatever you have in config.yaml to force downloading now.
     :param skip_dockerfile: If True, will not create a Dockerfile.
+    :param pat: Personal access token for authentication. If None, will use environment variables.
+    :param base_url: Base URL for the API. If None, will use environment variables.
     """
-    builder = ModelBuilder(folder, app_not_found_action="prompt")
+    builder = ModelBuilder(folder, app_not_found_action="prompt", pat=pat, base_url=base_url)
     builder.download_checkpoints(stage=stage)
     if not skip_dockerfile:
         builder.create_dockerfile()

clarifai/runners/server.py

@@ -28,7 +28,7 @@ def main():
     parser.add_argument(
         '--pool_size',
         type=int,
-        default=32,
+        default=os.environ.get('CLARIFAI_NUM_THREADS', 32),
         help="The number of threads to use for the gRPC server.",
         choices=range(1, 129),
     )  # pylint: disable=range-builtin-not-iterating

clarifai/runners/utils/code_script.py

@@ -127,7 +127,7 @@ from clarifai.runners.utils import data_types
 
     base_url_str = ""
     if base_url is not None:
-        base_url_str = f"base_url={base_url},"
+        base_url_str = f"base_url='{base_url}',"
 
     # Join all non-empty lines
     optional_lines = "\n    ".join(
@@ -321,7 +321,10 @@ def _set_default_value(field_type):
         default_value = f"{{{', '.join([str(et) for et in element_type_defaults])}}}"
 
     if is_iterator:
-        default_value = f'iter([{default_value}])'
+        if field_type == "str":
+            default_value = f"iter(['{default_value}'])"
+        else:
+            default_value = f"iter([{default_value}])"
     return default_value
 
 

clarifai/utils/constants.py

@@ -1,4 +1,5 @@
 import os
+from pathlib import Path
 
 DEFAULT_UI = os.environ.get("CLARIFAI_UI", "https://clarifai.com")
 DEFAULT_BASE = os.environ.get("CLARIFAI_API_BASE", "https://api.clarifai.com")
@@ -10,7 +11,8 @@ CLARIFAI_PAT_ENV_VAR = "CLARIFAI_PAT"
 CLARIFAI_SESSION_TOKEN_ENV_VAR = "CLARIFAI_SESSION_TOKEN"
 CLARIFAI_USER_ID_ENV_VAR = "CLARIFAI_USER_ID"
 
-DEFAULT_CONFIG = f'{os.environ["HOME"]}/.config/clarifai/config'
+HOME_PATH = Path.home()
+DEFAULT_CONFIG = HOME_PATH / '.config/clarifai/config'
 
 # Default clusters, etc. for local dev runner easy setup
 DEFAULT_LOCAL_DEV_COMPUTE_CLUSTER_ID = "local-dev-compute-cluster"

clarifai/utils/misc.py

@@ -1,11 +1,16 @@
 import os
 import re
+import shutil
+import subprocess
+import urllib.parse
 import uuid
 from typing import Any, Dict, List
 
 from clarifai_grpc.grpc.api.status import status_code_pb2
 
 from clarifai.errors import UserError
+from clarifai.utils.constants import HOME_PATH
+from clarifai.utils.logging import logger
 
 RETRYABLE_CODES = [
     status_code_pb2.MODEL_DEPLOYING,
@@ -13,7 +18,7 @@ RETRYABLE_CODES = [
     status_code_pb2.MODEL_BUSY_PLEASE_RETRY,
 ]
 
-DEFAULT_CONFIG = f'{os.environ["HOME"]}/.config/clarifai/config'
+DEFAULT_CONFIG = HOME_PATH / '.config/clarifai/config'
 
 
 def status_is_retryable(status_code: int) -> bool:
@@ -104,3 +109,60 @@ def clean_input_id(input_id: str) -> str:
     input_id = input_id.lower().strip('_-')
     input_id = re.sub('[^a-z0-9-_]+', '', input_id)
     return input_id
+
+
+def format_github_repo_url(github_repo):
+    """Format GitHub repository URL to a standard format."""
+    if github_repo.startswith('http'):
+        return github_repo
+    elif '/' in github_repo and not github_repo.startswith('git@'):
+        # Handle "user/repo" format
+        return f"https://github.com/{github_repo}.git"
+    else:
+        return github_repo
+
+
+def clone_github_repo(repo_url, target_dir, github_pat=None, branch=None):
+    """Clone a GitHub repository with optional GitHub PAT authentication and branch specification."""
+    # Handle local file paths - just copy instead of cloning
+    if os.path.exists(repo_url):
+        try:
+            shutil.copytree(repo_url, target_dir, ignore=shutil.ignore_patterns('.git'))
+            logger.info(f"Successfully copied local repository from {repo_url}")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to copy local repository: {e}")
+            return False
+
+    cmd = ["git", "clone"]
+
+    # Add branch specification if provided
+    if branch:
+        cmd.extend(["-b", branch])
+
+    # Handle authentication with GitHub PAT
+    if github_pat:
+        # Parse the URL and validate the hostname
+        parsed_url = urllib.parse.urlparse(repo_url)
+        if parsed_url.hostname == "github.com":
+            # Insert GitHub PAT into the URL for authentication
+            authenticated_url = f"https://{github_pat}@{parsed_url.netloc}{parsed_url.path}"
+            cmd.append(authenticated_url)
+        else:
+            logger.error(f"Invalid repository URL: {repo_url}")
+            return False
+    else:
+        cmd.append(repo_url)
+
+    cmd.append(target_dir)
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        if branch:
+            logger.info(f"Successfully cloned repository from {repo_url} (branch: {branch})")
+        else:
+            logger.info(f"Successfully cloned repository from {repo_url}")
+        return True
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Failed to clone repository: {e.stderr}")
+        return False

{clarifai-11.5.6.dist-info → clarifai-11.6.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clarifai
-Version: 11.5.6
+Version: 11.6.1
 Home-page: https://github.com/Clarifai/clarifai-python
 Author: Clarifai
 Author-email: support@clarifai.com
@@ -19,8 +19,8 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: clarifai-grpc>=11.5.5
-Requires-Dist: clarifai-protocol>=0.0.24
+Requires-Dist: clarifai-grpc>=11.6.0
+Requires-Dist: clarifai-protocol>=0.0.25
 Requires-Dist: numpy>=1.22.0
 Requires-Dist: tqdm>=4.65.0
 Requires-Dist: PyYAML>=6.0.1

{clarifai-11.5.6.dist-info → clarifai-11.6.1.dist-info}/RECORD

@@ -1,22 +1,22 @@
-clarifai/__init__.py,sha256=BxuXNC41hShXWv3SgslBYu8ufM3yw21Lbp4jemirGjY,23
+clarifai/__init__.py,sha256=VWnuXh96XOfxTdsGBlgaKktRmz_G17IZGf8-J8ntbcs,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
 clarifai/cli/README.md,sha256=YGApHfeUyu5P0Pdth-mqQCQftWHDxz6bugDlvDXDhOE,1942
 clarifai/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 clarifai/cli/__main__.py,sha256=7nPbLW7Jr2shkgMPvnxpn4xYGMvIcnqluJ69t9w4H_k,74
-clarifai/cli/base.py,sha256=mzfAHRhon6tKntpxk241GD-Sjrb2-V99nAOasElLuuw,8254
+clarifai/cli/base.py,sha256=SNJL5TEcB2rD6pX1v_nrMCH9F7IJ_TD6XXI95cJCi3I,8330
 clarifai/cli/compute_cluster.py,sha256=8Xss0Obrp6l1XuxJe0luOqU_pf8vXGDRi6jyIe8qR6k,2282
 clarifai/cli/deployment.py,sha256=9C4I6_kyMxRkWl6h681wc79-3mAtDHtTUaxRv05OZMs,4262
-clarifai/cli/model.py,sha256=71u7JS0xnxQOLp3s9cKGbT1hyhf1CIVxMeFMU2fiLTM,31553
+clarifai/cli/model.py,sha256=Kigk6lFy179Puvlgb26Gllra32Sy_WaIayR0ImJ8ZJE,35639
 clarifai/cli/nodepool.py,sha256=H6OIdUW_EiyDUwZogzEDoYmVwEjLMsgoDlPyE7gjIuU,4245
-clarifai/cli/pipeline.py,sha256=M8gW72IB5hx1OIf0pOytZhnw50euPnXxW4vuZ9Fqyqw,5477
-clarifai/cli/pipeline_step.py,sha256=eOxU4MdPBuB01A00Rz6m9THLyTaTLOTKwGwSVyegkyI,3808
+clarifai/cli/pipeline.py,sha256=smWPCK9kLCqnjTCb3w8BAeiAcowY20Bdxfk-OCzCi0I,10601
+clarifai/cli/pipeline_step.py,sha256=Unrq63w5rjwyhHHmRhV-enztO1HuVTnimAXltNCotQs,3814
 clarifai/cli/templates/__init__.py,sha256=HbMlZuYOMyVJde73ijNAevmSRUpIttGlHdwyO4W-JOs,44
 clarifai/cli/templates/model_templates.py,sha256=_ZonIBnY9KKSJY31KZbUys_uN_k_Txu7Dip12KWfmSU,9633
 clarifai/cli/templates/pipeline_step_templates.py,sha256=HU1BoU7wG71MviQAvyecxT_qo70XhTtPGYtoIQ-U-l0,1663
 clarifai/cli/templates/pipeline_templates.py,sha256=mfHrEoRxICIv00zxfgIct2IpxcMmZ6zjHG8WLF1TPcI,4409
-clarifai/client/__init__.py,sha256=NhpNFRJY6mTi8ca-5hUeTEmYeDKHDNXY48FN63pDuos,703
+clarifai/client/__init__.py,sha256=KXvZFE9TCJf1k_GNUHCZ4icsUlKr1lz0cnBR91LuY8M,765
 clarifai/client/app.py,sha256=1M9XDsPWIEsj0g-mgIeZ9Mvkt85UHSbrv6pEr-QKfNg,41423
 clarifai/client/base.py,sha256=rXQlB0BXbKLOgLVJW_2axYh0Vd_F0BbgJE_DXTQoG4U,9109
 clarifai/client/compute_cluster.py,sha256=ViPyh-FibXL1J0ypsVOTaQnR1ymKohmZEuA13RwA-hc,10254
@@ -24,10 +24,11 @@ clarifai/client/dataset.py,sha256=OgdpZkQ_vYmRxL8-qphcNozpvPV1bWTlte9Jv6UkKb8,35
 clarifai/client/deployment.py,sha256=QBf0tzkKBEpzNgmOEmWUJMOlVWdFEFc70Y44o8y75Gs,2875
 clarifai/client/input.py,sha256=jpX47qwn7aUBBIEuSSLHF5jk70XaWEh0prD065c9b-E,51205
 clarifai/client/lister.py,sha256=1YEm2suNxPaJO4x9V5szgD_YX6N_00vgSO-7m0HagY8,2208
-clarifai/client/model.py,sha256=8D_L6nuL4_hBAKgwseYhoAeKS9u3ky0zczkcJghxFe8,90072
+clarifai/client/model.py,sha256=rGNeMgL8kgEUsB3Y1lSl6CfE1XuXY0me57-8_o2TNn4,90726
 clarifai/client/model_client.py,sha256=4gIS0mKBdiNMA1x_6Wo6H7WbfLsmQix64EpONcQjQV4,37129
 clarifai/client/module.py,sha256=jLViQYvVV3FmRN_ivvbk83uwsx7CgYGeEx4dYAr6yD4,4537
 clarifai/client/nodepool.py,sha256=Y5zQ0JLdTjAp2TmVnx7AAOwaB2YUslk3nl7s6BQ90FQ,16415
+clarifai/client/pipeline.py,sha256=Hy3qnSX1pcoi-OAtdzr-qxkRYi1CxsaUzsfS3GDtETM,14358
 clarifai/client/runner.py,sha256=5xCiqByGGscfNm0IjHelhDTx8-9l8G0C3HL-3YZogK8,2253
 clarifai/client/search.py,sha256=3LLfATrdU43a0mRNITmJV-E53bhfafZkYsbwkTtlnyU,15661
 clarifai/client/user.py,sha256=YDAXSOh7ACsvCjVctugiTu8MXFN_TDBoXuEKGXv_uHg,21997
@@ -70,12 +71,12 @@ clarifai/rag/__init__.py,sha256=wu3PzAzo7uqgrEzuaC9lY_3gj1HFiR3GU3elZIKTT5g,40
 clarifai/rag/rag.py,sha256=EG3GoFrHFCmA70Tz49_0Jo1-3WIaHSgWGHecPeErcdc,14170
 clarifai/rag/utils.py,sha256=_gVZdABuMnraCKViLruV75x0F3IpgFXN6amYSGE5_xc,4462
 clarifai/runners/__init__.py,sha256=wXLaSljH7qLeJCrZdKEnlQh2tNqTQAIZKWOu2rZ6wGs,279
-clarifai/runners/server.py,sha256=9qVAs8pRHmtyY0RCNIQ1uP8nqDADIFZ03LnkoDt1h4U,4692
+clarifai/runners/server.py,sha256=YNK2ZjVsAzpULJ6cBAJotrL3xSJ_Gx3VodbBY_Fa7kQ,4732
 clarifai/runners/dockerfile_template/Dockerfile.template,sha256=DUH7F0-uLOV0LTjnPde-9chSzscAAxBAwjTxi9b_l9g,2425
 clarifai/runners/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 clarifai/runners/models/dummy_openai_model.py,sha256=pcmAVbqTTGG4J3BLVjKfvM_SQ-GET_XexIUdLcr9Zvo,8373
 clarifai/runners/models/mcp_class.py,sha256=RdKn7rW4vYol0VRDZiLTSMfkqjLhO1ijXAQ0Rq0Jfnw,6647
-clarifai/runners/models/model_builder.py,sha256=lzXf1H4oQ4l672xHoXSaT4bi0z0vTj3YnziT7RRRLIg,63695
+clarifai/runners/models/model_builder.py,sha256=JAf6nPuL5Esus5g3RL_Cq1-9-ZkgDhe2DXtcvDHuOuY,64701
 clarifai/runners/models/model_class.py,sha256=Ndh437BNMkpFBo6B108GuKL8sGYaGnSplZ6FxOgd_v8,20010
 clarifai/runners/models/model_run_locally.py,sha256=6-6WjEKc0ba3gAv4wOLdMs2XOzS3b-2bZHJS0wdVqJY,20088
 clarifai/runners/models/model_runner.py,sha256=tZTX1XKMlniJEmd1WMjcwGfej5NCWqv23HZ4xrG8YV8,9153
@@ -88,7 +89,7 @@ clarifai/runners/pipeline_steps/pipeline_step_builder.py,sha256=E6Ce3b0RolYLMJHa
 clarifai/runners/pipelines/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 clarifai/runners/pipelines/pipeline_builder.py,sha256=z_bCwjwQPFa_1AYkorhh5r6t6r5hC5K2D8Z1LTEzIpg,12801
 clarifai/runners/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-clarifai/runners/utils/code_script.py,sha256=RxN4UOBIa61WW1U5y-gC-dwr_tY8ZAKr1nR8sySNWt4,13922
+clarifai/runners/utils/code_script.py,sha256=toHoQQ2UGGmAxhFrbHo8217eJpUbAa-8RyPzTzfqXvk,14031
 clarifai/runners/utils/const.py,sha256=MK7lTzzJKbOiyiUtG_jlJXfz_xNKMn5LjkQ9vjbttXE,1538
 clarifai/runners/utils/data_utils.py,sha256=HRpMYR2O0OiDpXXhOManLHTeomC4bFnXMHVAiT_12yE,20856
 clarifai/runners/utils/loader.py,sha256=K5Y8MPbIe5STw2gDnrL8KqFgKNxEo7bz-RV0ip1T4PM,10900
@@ -105,9 +106,9 @@ clarifai/urls/helper.py,sha256=z6LnLGgLHxD8scFtyRdxqYIRJNhxqPkfLe53UtTLUBY,11727
 clarifai/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 clarifai/utils/cli.py,sha256=7lHajIsWzyEU7jfgH1nykwYG63wcHCZ3ep7a6amWZH4,5413
 clarifai/utils/config.py,sha256=jMSWYxJfp_D8eoGqz-HTdsngn5bg_1ymjLidYz6rdLA,7073
-clarifai/utils/constants.py,sha256=nvKNAOnfvHza03mYHVLfyOfm_AcFiNKr2CzwyEQgoQI,2110
+clarifai/utils/constants.py,sha256=2rbMQtH-EhQsI0FrOCmzw6P-kK6zUzrZiXdBMEXe3ts,2149
 clarifai/utils/logging.py,sha256=0we53uTqUvzrulC86whu-oeWNxn1JjJL0OQ98Bwf9vo,15198
-clarifai/utils/misc.py,sha256=x7JP8oxU672Z9yAav47Y1anFiL4RD8WvlKBHMVlbyZM,3137
+clarifai/utils/misc.py,sha256=ug5A7m_WdLtFip5_U1jbvT6ZsmsCzFQatjE3B-KcaAQ,5387
 clarifai/utils/model_train.py,sha256=0XSAoTkSsrwf4f-W9yw2mkXZtkal7LBLJSoi86CFCn4,9250
 clarifai/utils/protobuf.py,sha256=VMhnNsPuWQ16VarKm8BOr5zccXMe26UlrxdJxIzEZNM,6220
 clarifai/utils/evaluation/__init__.py,sha256=PYkurUrXrGevByj7RFb6CoU1iC7fllyQSfnnlo9WnY8,69
@@ -118,9 +119,9 @@ clarifai/workflows/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuF
 clarifai/workflows/export.py,sha256=HvUYG9N_-UZoRR0-_tdGbZ950_AeBqawSppgUxQebR0,1913
 clarifai/workflows/utils.py,sha256=ESL3INcouNcLKCh-nMpfXX-YbtCzX7tz7hT57_RGQ3M,2079
 clarifai/workflows/validate.py,sha256=UhmukyHkfxiMFrPPeBdUTiCOHQT5-shqivlBYEyKTlU,2931
-clarifai-11.5.6.dist-info/licenses/LICENSE,sha256=mUqF_d12-qE2n41g7C5_sq-BMLOcj6CNN-jevr15YHU,555
-clarifai-11.5.6.dist-info/METADATA,sha256=dE9Pb314d6-aAeFuNetMEyt6GsbveEuJdqnjTbeln7E,22737
-clarifai-11.5.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-clarifai-11.5.6.dist-info/entry_points.txt,sha256=X9FZ4Z-i_r2Ud1RpZ9sNIFYuu_-9fogzCMCRUD9hyX0,51
-clarifai-11.5.6.dist-info/top_level.txt,sha256=wUMdCQGjkxaynZ6nZ9FAnvBUCgp5RJUVFSy2j-KYo0s,9
-clarifai-11.5.6.dist-info/RECORD,,
+clarifai-11.6.1.dist-info/licenses/LICENSE,sha256=mUqF_d12-qE2n41g7C5_sq-BMLOcj6CNN-jevr15YHU,555
+clarifai-11.6.1.dist-info/METADATA,sha256=RgPz0HAbwwljL7tmub8NpB1LB5EZOByg_wfo-gGQ9nc,22737
+clarifai-11.6.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+clarifai-11.6.1.dist-info/entry_points.txt,sha256=X9FZ4Z-i_r2Ud1RpZ9sNIFYuu_-9fogzCMCRUD9hyX0,51
+clarifai-11.6.1.dist-info/top_level.txt,sha256=wUMdCQGjkxaynZ6nZ9FAnvBUCgp5RJUVFSy2j-KYo0s,9
+clarifai-11.6.1.dist-info/RECORD,,