clarifai 11.8.4__py3-none-any.whl → 11.9.0__py3-none-any.whl

clarifai/__init__.py

@@ -1 +1 @@
-__version__ = "11.8.4"
+__version__ = "11.9.0"

clarifai/cli/model.py

@@ -29,6 +29,7 @@ from clarifai.utils.constants import (
     DEFAULT_LOCAL_RUNNER_NODEPOOL_ID,
     DEFAULT_OLLAMA_MODEL_REPO_BRANCH,
     DEFAULT_PYTHON_MODEL_REPO_BRANCH,
+    DEFAULT_SGLANG_MODEL_REPO_BRANCH,
     DEFAULT_TOOLKIT_MODEL_REPO,
     DEFAULT_VLLM_MODEL_REPO_BRANCH,
 )
@@ -76,15 +77,15 @@ def model():
 @click.option(
     '--toolkit',
     type=click.Choice(
-        ['ollama', 'huggingface', 'lmstudio', 'vllm', 'python'], case_sensitive=False
+        ['ollama', 'huggingface', 'lmstudio', 'vllm', 'sglang', 'python'], case_sensitive=False
     ),
     required=False,
-    help='Toolkit to use for model initialization. Currently supports "ollama", "huggingface", "lmstudio", "vllm" and "python".',
+    help='Toolkit to use for model initialization. Currently supports "ollama", "huggingface", "lmstudio", "vllm", "sglang" and "python".',
 )
 @click.option(
     '--model-name',
     required=False,
-    help='Model name to configure when using --toolkit. For ollama toolkit, this sets the Ollama model to use (e.g., "llama3.1", "mistral", etc.). For vllm & huggingface toolkit, this sets the Hugging Face model repo_id (e.g., "unsloth/Llama-3.2-1B-Instruct").\n For lmstudio toolkit, this sets the LM Studio model name (e.g., "qwen/qwen3-4b-thinking-2507").\n',
+    help='Model name to configure when using --toolkit. For ollama toolkit, this sets the Ollama model to use (e.g., "llama3.1", "mistral", etc.). For vllm, sglang & huggingface toolkit, this sets the Hugging Face model repo_id (e.g., "unsloth/Llama-3.2-1B-Instruct").\n For lmstudio toolkit, this sets the LM Studio model name (e.g., "qwen/qwen3-4b-thinking-2507").\n',
 )
 @click.option(
     '--port',
@@ -129,8 +130,8 @@ def init(
     MODEL_TYPE_ID: Type of model to create. If not specified, defaults to "text-to-text" for text models.\n
     GITHUB_PAT: GitHub Personal Access Token for authentication when cloning private repositories.\n
     GITHUB_URL: GitHub repository URL or "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.\n
-    TOOLKIT: Toolkit to use for model initialization. Currently supports "ollama", "huggingface", "lmstudio", "vllm" and "python".\n
-    MODEL_NAME: Model name to configure when using --toolkit. For ollama toolkit, this sets the Ollama model to use (e.g., "llama3.1", "mistral", etc.). For vllm & huggingface toolkit, this sets the Hugging Face model repo_id (e.g., "Qwen/Qwen3-4B-Instruct-2507"). For lmstudio toolkit, this sets the LM Studio model name (e.g., "qwen/qwen3-4b-thinking-2507").\n
+    TOOLKIT: Toolkit to use for model initialization. Currently supports "ollama", "huggingface", "lmstudio", "vllm", "sglang" and "python".\n
+    MODEL_NAME: Model name to configure when using --toolkit. For ollama toolkit, this sets the Ollama model to use (e.g., "llama3.1", "mistral", etc.). For vllm, sglang & huggingface toolkit, this sets the Hugging Face model repo_id (e.g., "Qwen/Qwen3-4B-Instruct-2507"). For lmstudio toolkit, this sets the LM Studio model name (e.g., "qwen/qwen3-4b-thinking-2507").\n
     PORT: Port to run the (Ollama/lmstudio) server on. Defaults to 23333.\n
     CONTEXT_LENGTH: Context length for the (Ollama/lmstudio) model. Defaults to 8192.\n
     """
@@ -183,6 +184,9 @@ def init(
     elif toolkit == 'vllm':
         github_url = DEFAULT_TOOLKIT_MODEL_REPO
         branch = DEFAULT_VLLM_MODEL_REPO_BRANCH
+    elif toolkit == 'sglang':
+        github_url = DEFAULT_TOOLKIT_MODEL_REPO
+        branch = DEFAULT_SGLANG_MODEL_REPO_BRANCH
     elif toolkit == 'python':
         github_url = DEFAULT_TOOLKIT_MODEL_REPO
         branch = DEFAULT_PYTHON_MODEL_REPO_BRANCH
@@ -320,7 +324,9 @@ def init(
     if (user_id or model_name or port or context_length) and (toolkit == 'lmstudio'):
         customize_lmstudio_model(model_path, user_id, model_name, port, context_length)
 
-    if (user_id or model_name) and (toolkit == 'huggingface' or toolkit == 'vllm'):
+    if (user_id or model_name) and (
+        toolkit == 'huggingface' or toolkit == 'vllm' or toolkit == 'sglang'
+    ):
         # Update the config.yaml file with the provided model name
         customize_huggingface_model(model_path, user_id, model_name)
 
@@ -1010,6 +1016,7 @@ def local_runner(ctx, model_path, pool_size, verbose):
             logger.info("Customizing Ollama model with provided parameters...")
             customize_ollama_model(
                 model_path=model_path,
+                user_id=user_id,
                 verbose=True if verbose else False,
             )
         except Exception as e:

clarifai/client/__init__.py

@@ -2,11 +2,14 @@ from clarifai.client.app import App
 from clarifai.client.auth.register import V2Stub
 from clarifai.client.auth.stub import create_stub
 from clarifai.client.base import BaseClient
+from clarifai.client.compute_cluster import ComputeCluster
 from clarifai.client.dataset import Dataset
+from clarifai.client.deployment import Deployment
 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.nodepool import Nodepool
 from clarifai.client.pipeline import Pipeline
 from clarifai.client.pipeline_step import PipelineStep
 from clarifai.client.search import Search
@@ -28,4 +31,7 @@ __all__ = [
     'Inputs',
     'BaseClient',
     'Search',
+    'ComputeCluster',
+    'Nodepool',
+    'Deployment',
 ]

clarifai/client/model_client.py

@@ -11,6 +11,7 @@ from clarifai.constants.model import MAX_MODEL_PREDICT_INPUTS
 from clarifai.errors import UserError
 from clarifai.runners.utils import code_script, method_signatures
 from clarifai.runners.utils.method_signatures import (
+    RESERVED_PARAM_WITH_PROTO,
     CompatibilitySerializer,
     deserialize,
     get_stream_from_signature,
@@ -204,6 +205,9 @@ class ModelClient:
 
             def bind_f(method_name, method_argnames, call_func, async_call_func):
                 def sync_f(*args, **kwargs):
+                    # Extract with_proto parameter if present
+                    with_proto = kwargs.pop(RESERVED_PARAM_WITH_PROTO, False)
+
                     if len(args) > len(method_argnames):
                         raise TypeError(
                             f"{method_name}() takes {len(method_argnames)} positional arguments but {len(args)} were given"
@@ -221,7 +225,7 @@ class ModelClient:
                         )
                         if is_batch_input_valid and (not is_openai_chat_format(batch_inputs)):
                             # If the batch input is valid, call the function with the batch inputs and the method name
-                            return call_func(batch_inputs, method_name)
+                            return call_func(batch_inputs, method_name, with_proto=with_proto)
 
                     for name, arg in zip(
                         method_argnames, args
@@ -229,10 +233,13 @@ class ModelClient:
                         if name in kwargs:
                             raise TypeError(f"Multiple values for argument {name}")
                         kwargs[name] = arg
-                    return call_func(kwargs, method_name)
+                    return call_func(kwargs, method_name, with_proto=with_proto)
 
                 async def async_f(*args, **kwargs):
                     # Async version to call the async function
+                    # Extract with_proto parameter if present
+                    with_proto = kwargs.pop(RESERVED_PARAM_WITH_PROTO, False)
+
                     if len(args) > len(method_argnames):
                         raise TypeError(
                             f"{method_name}() takes {len(method_argnames)} positional arguments but {len(args)} were given"
@@ -249,7 +256,9 @@ class ModelClient:
                         )
                         if is_batch_input_valid and (not is_openai_chat_format(batch_inputs)):
                             # If the batch input is valid, call the function with the batch inputs and the method name
-                            return async_call_func(batch_inputs, method_name)
+                            return async_call_func(
+                                batch_inputs, method_name, with_proto=with_proto
+                            )
 
                     for name, arg in zip(
                         method_argnames, args
@@ -258,7 +267,7 @@ class ModelClient:
                             raise TypeError(f"Multiple values for argument {name}")
                         kwargs[name] = arg
 
-                    return async_call_func(kwargs, method_name)
+                    return async_call_func(kwargs, method_name, with_proto=with_proto)
 
                 class MethodWrapper:
                     def __call__(self, *args, **kwargs):
@@ -364,6 +373,7 @@ class ModelClient:
         self,
         inputs,  # TODO set up functions according to fetched signatures?
         method_name: str = 'predict',
+        with_proto: bool = False,
     ) -> Any:
         input_signature = self._method_signatures[method_name].input_fields
         output_signature = self._method_signatures[method_name].output_fields
@@ -385,9 +395,12 @@ class ModelClient:
         outputs = []
         for output in response.outputs:
             outputs.append(deserialize(output.data, output_signature, is_output=True))
-        if batch_input:
-            return outputs
-        return outputs[0]
+
+        result = outputs if batch_input else outputs[0]
+
+        if with_proto:
+            return result, response
+        return result
 
     def _predict_by_proto(
         self,
@@ -448,15 +461,17 @@ class ModelClient:
         self,
         inputs,
         method_name: str = 'predict',
+        with_proto: bool = False,
     ) -> Any:
         """Asynchronously process inputs and make predictions.
 
         Args:
             inputs: Input data to process
             method_name (str): Name of the method to call
+            with_proto (bool): If True, return both the processed result and the raw protobuf response
 
         Returns:
-            Processed prediction results
+            Processed prediction results, optionally with protobuf response
         """
         # method_name is set to 'predict' by default, this is because to replicate the input and output signature behaviour of sync to async predict.
         input_signature = self._method_signatures[method_name].input_fields
@@ -477,7 +492,11 @@ class ModelClient:
         for output in response.outputs:
             outputs.append(deserialize(output.data, output_signature, is_output=True))
 
-        return outputs if batch_input else outputs[0]
+        result = outputs if batch_input else outputs[0]
+
+        if with_proto:
+            return result, response
+        return result
 
     async def _async_predict_by_proto(
         self,
@@ -551,6 +570,7 @@ class ModelClient:
         self,
         inputs,  # TODO set up functions according to fetched signatures?
         method_name: str = 'generate',
+        with_proto: bool = False,
     ) -> Any:
         input_signature = self._method_signatures[method_name].input_fields
         output_signature = self._method_signatures[method_name].output_fields
@@ -572,10 +592,13 @@ class ModelClient:
             outputs = []
             for output in response.outputs:
                 outputs.append(deserialize(output.data, output_signature, is_output=True))
-            if batch_input:
-                yield outputs
+
+            result = outputs if batch_input else outputs[0]
+
+            if with_proto:
+                yield result, response
             else:
-                yield outputs[0]
+                yield result
 
     def _generate_by_proto(
         self,
@@ -641,6 +664,7 @@ class ModelClient:
         self,
         inputs,
         method_name: str = 'generate',
+        with_proto: bool = False,
     ) -> Any:
         # method_name is set to 'generate' by default, this is because to replicate the input and output signature behaviour of sync to async generate.
         input_signature = self._method_signatures[method_name].input_fields
@@ -654,18 +678,21 @@ class ModelClient:
         proto_inputs = []
         for input in inputs:
             proto = resources_pb2.Input()
-        serialize(input, input_signature, proto.data)
-        proto_inputs.append(proto)
+            serialize(input, input_signature, proto.data)
+            proto_inputs.append(proto)
         response_stream = self._async_generate_by_proto(proto_inputs, method_name)
 
         async for response in response_stream:
             outputs = []
             for output in response.outputs:
                 outputs.append(deserialize(output.data, output_signature, is_output=True))
-            if batch_input:
-                yield outputs
+
+            result = outputs if batch_input else outputs[0]
+
+            if with_proto:
+                yield result, response
             else:
-                yield outputs[0]
+                yield result
 
     async def _async_generate_by_proto(
         self,
@@ -734,6 +761,7 @@ class ModelClient:
         self,
         inputs,
         method_name: str = 'stream',
+        with_proto: bool = False,
     ) -> Any:
         input_signature = self._method_signatures[method_name].input_fields
         output_signature = self._method_signatures[method_name].output_fields
@@ -775,7 +803,12 @@ class ModelClient:
 
         for response in response_stream:
             assert len(response.outputs) == 1, 'streaming methods must have exactly one output'
-            yield deserialize(response.outputs[0].data, output_signature, is_output=True)
+            result = deserialize(response.outputs[0].data, output_signature, is_output=True)
+
+            if with_proto:
+                yield result, response
+            else:
+                yield result
 
     def _req_iterator(
         self,
@@ -843,6 +876,7 @@ class ModelClient:
         self,
         inputs,
         method_name: str = 'stream',
+        with_proto: bool = False,
     ) -> Any:
         # method_name is set to 'stream' by default, this is because to replicate the input and output signature behaviour of sync to async stream.
         input_signature = self._method_signatures[method_name].input_fields
@@ -885,7 +919,12 @@ class ModelClient:
 
         async for response in response_stream:
             assert len(response.outputs) == 1, 'streaming methods must have exactly one output'
-            yield deserialize(response.outputs[0].data, output_signature, is_output=True)
+            result = deserialize(response.outputs[0].data, output_signature, is_output=True)
+
+            if with_proto:
+                yield result, response
+            else:
+                yield result
 
     async def _async_stream_by_proto(
         self,

clarifai/runners/models/model_builder.py

@@ -8,7 +8,7 @@ import subprocess
 import sys
 import tarfile
 import time
-import webbrowser
+import uuid
 from string import Template
 from typing import Any, Dict, Literal, Optional
 from unittest.mock import MagicMock
@@ -18,8 +18,10 @@ 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 import Model, Nodepool
 from clarifai.client.base import BaseClient
 from clarifai.client.user import User
+from clarifai.errors import UserError
 from clarifai.runners.models.model_class import ModelClass
 from clarifai.runners.utils import code_script
 from clarifai.runners.utils.const import (
@@ -41,7 +43,9 @@ from clarifai.runners.utils.loader import HuggingFaceLoader
 from clarifai.runners.utils.method_signatures import signatures_to_yaml
 from clarifai.urls.helper import ClarifaiUrlHelper
 from clarifai.utils.logging import logger
-from clarifai.versions import CLIENT_VERSION
+from clarifai.versions import get_latest_version_from_pypi
+
+CLARIFAI_LATEST_VERSION = get_latest_version_from_pypi()
 
 # parse the user's requirements.txt to determine the proper base image to build on top of, based on the torch and other large dependencies and it's versions
 # List of dependencies to look for
@@ -65,6 +69,88 @@ def is_related(object_class, main_class):
     return False
 
 
+def get_user_input(prompt, required=True, default=None):
+    """Get user input with optional default value."""
+    if default:
+        prompt = f"{prompt} [{default}]: "
+    else:
+        prompt = f"{prompt}: "
+
+    while True:
+        value = input(prompt).strip()
+        if not value and default:
+            return default
+        if not value and required:
+            print("❌ This field is required. Please enter a value.")
+            continue
+        return value
+
+
+def get_yes_no_input(prompt, default=None):
+    """Get yes/no input from user."""
+    if default is not None:
+        prompt = f"{prompt} [{'Y/n' if default else 'y/N'}]: "
+    else:
+        prompt = f"{prompt} [y/n]: "
+
+    while True:
+        response = input(prompt).strip().lower()
+        if not response and default is not None:
+            return default
+        if response in ['y', 'yes']:
+            return True
+        if response in ['n', 'no']:
+            return False
+        print("❌ Please enter 'y' or 'n'.")
+
+
+def select_compute_option(user_id: str):
+    """
+    Dynamically list compute-clusters and node-pools that belong to `user_id`
+    and return a dict with nodepool_id, compute_cluster_id, cluster_user_id.
+    """
+    user = User(user_id=user_id)  # PAT / BASE URL are picked from env-vars
+    clusters = list(user.list_compute_clusters())
+    if not clusters:
+        print("❌ No compute clusters found for this user.")
+        return None
+    print("\n🖥️  Available Compute Clusters:")
+    for idx, cc in enumerate(clusters, 1):
+        desc = getattr(cc, "description", "") or "No description"
+        print(f"{idx}. {cc.id}  –  {desc}")
+    while True:
+        try:
+            sel = int(input("Select compute cluster (number): ")) - 1
+            if 0 <= sel < len(clusters):
+                cluster = clusters[sel]
+                break
+            print("❌ Invalid selection.")
+        except ValueError:
+            print("❌ Please enter a number.")
+    nodepools = list(cluster.list_nodepools())
+    if not nodepools:
+        print("❌ No nodepools in selected cluster.")
+        return None
+    print("\n📦  Available Nodepools:")
+    for idx, np in enumerate(nodepools, 1):
+        desc = getattr(np, "description", "") or "No description"
+        print(f"{idx}. {np.id}  –  {desc}")
+    while True:
+        try:
+            sel = int(input("Select nodepool (number): ")) - 1
+            if 0 <= sel < len(nodepools):
+                nodepool = nodepools[sel]
+                break
+            print("❌ Invalid selection.")
+        except ValueError:
+            print("❌ Please enter a number.")
+    return {
+        "nodepool_id": nodepool.id,
+        "compute_cluster_id": cluster.id,
+        "cluster_user_id": getattr(cluster, "user_id", user_id),
+    }
+
+
 class ModelBuilder:
     DEFAULT_CHECKPOINT_SIZE = 50 * 1024**3  # 50 GiB
 
@@ -1068,26 +1154,28 @@ class ModelBuilder:
                         break
         if 'clarifai' not in dependencies:
             raise Exception(
-                f"clarifai not found in requirements.txt, please add clarifai to the requirements.txt file with a fixed version. Current version is clarifai=={CLIENT_VERSION}"
+                f"clarifai not found in requirements.txt, please add clarifai to the requirements.txt file with a fixed version. Current version is clarifai=={CLARIFAI_LATEST_VERSION}"
             )
         clarifai_version = dependencies['clarifai']
         if not clarifai_version:
             logger.warn(
-                f"clarifai version not found in requirements.txt, using the latest version {CLIENT_VERSION}"
+                f"clarifai version not found in requirements.txt, using the latest version {CLARIFAI_LATEST_VERSION}"
             )
-            clarifai_version = CLIENT_VERSION
+            clarifai_version = CLARIFAI_LATEST_VERSION
             lines = []
             with open(os.path.join(self.folder, 'requirements.txt'), 'r') as file:
                 for line in file:
                     # if the line without whitespace is "clarifai"
                     dependency, version = self._match_req_line(line)
                     if dependency and dependency == "clarifai":
-                        lines.append(line.replace("clarifai", f"clarifai=={CLIENT_VERSION}"))
+                        lines.append(
+                            line.replace("clarifai", f"clarifai=={CLARIFAI_LATEST_VERSION}")
+                        )
                     else:
                         lines.append(line)
             with open(os.path.join(self.folder, 'requirements.txt'), 'w') as file:
                 file.writelines(lines)
-            logger.warn(f"Updated requirements.txt to have clarifai=={CLIENT_VERSION}")
+            logger.warn(f"Updated requirements.txt to have clarifai=={CLARIFAI_LATEST_VERSION}")
 
         # Replace placeholders with actual values
         dockerfile_content = dockerfile_template.safe_substitute(
@@ -1502,6 +1590,7 @@ class ModelBuilder:
         self.model_version_id = response.model_version_id
         logger.info(f"Created Model Version ID: {self.model_version_id}")
         logger.info(f"Full url to that version is: {self.model_ui_url}")
+        is_uploaded = False
         try:
             is_uploaded = self.monitor_model_build()
             if is_uploaded:
@@ -1516,15 +1605,21 @@ class ModelBuilder:
                     colorize=True,
                 )
                 logger.info("""\n
-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 # Here is a code snippet to use this model:
 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
                 """)
                 logger.info(snippet)
+                logger.info("""\n
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+                """)
         finally:
             if os.path.exists(self.tar_file):
                 logger.debug(f"Cleaning up upload file: {self.tar_file}")
                 os.remove(self.tar_file)
+        if is_uploaded:
+            return self.model_version_id
 
     def model_version_stream_upload_iterator(self, model_version_proto, file_path):
         yield self.init_upload_model_version(model_version_proto, file_path)
@@ -1682,204 +1777,257 @@ def upload_model(folder, stage, skip_dockerfile, pat=None, base_url=None):
 
     # Ask user if they want to deploy the model
     if model_version is not None:  # if it comes back None then it failed.
-        deploy_model = input("Do you want to deploy the model? (y/n): ")
-        if deploy_model.lower() != 'y':
+        if get_yes_no_input("\n🔶 Do you want to deploy the model?", True):
+            # Setup deployment for the uploaded model
+            setup_deployment_for_model(builder)
+        else:
             logger.info("Model uploaded successfully. Skipping deployment setup.")
             return
 
-        # Setup deployment for the uploaded model
-        setup_deployment_for_model(builder)
+
+def deploy_model(
+    model_url=None,
+    model_id=None,
+    app_id=None,
+    user_id=None,
+    deployment_id=None,
+    model_version_id=None,
+    nodepool_id=None,
+    compute_cluster_id=None,
+    cluster_user_id=None,
+    min_replicas=0,
+    max_replicas=5,
+):
+    """
+    Deploy a model on Clarifai platform.
+    Args:
+        model_url (str): The full Clarifai model URL (optional if model_id is provided).
+        model_id (str): The ID of the model to be deployed (optional if model_url is provided).
+        app_id (str): The application ID where the model resides.
+        user_id (str): The user ID who owns the model.
+        deployment_id (str): The ID for the new deployment.
+        model_version_id (str): The version ID of the model to deploy. If not provided, the latest version will be used.
+        nodepool_id (str): The ID of the nodepool where the deployment will be created.
+        compute_cluster_id (str): The ID of the compute cluster to use for deployment.
+        cluster_user_id (str): The user ID that owns the compute cluster.
+        min_replicas (int): Minimum number of replicas for autoscaling.
+        max_replicas (int): Maximum number of replicas for autoscaling.
+    """
+    if model_url and model_id:
+        raise UserError("You can only specify one of url or model_id.")
+    if not model_url and not model_id:
+        raise UserError("You must specify one of url or model_id.")
+    if model_url:
+        user_id, app_id, _, model_id, _ = ClarifaiUrlHelper.split_clarifai_url(model_url)
+    if not model_version_id:
+        model = Model(model_id=model_id, app_id=app_id, user_id=user_id)
+        model_versions = [v for v in model.list_versions()]
+        if not model_versions:
+            raise UserError(f"No versions found for model {model_id}.")
+        if len(model_versions) > 1:
+            # model_version_id = model_versions[len(model_versions) - 1].model_version.id # Use the first version
+            model_version_id = model_versions[0].model_version.id  # latest version
+
+    # Construct the full deployment config
+    deployment_config = {
+        "deployment": {
+            "id": deployment_id,
+            "user_id": user_id,
+            "description": "Model deployment created to test Model upload",
+            "autoscale_config": {
+                "min_replicas": min_replicas,
+                "max_replicas": max_replicas,
+                "traffic_history_seconds": 600,
+                "scale_down_delay_seconds": 300,
+                "scale_to_zero_delay_seconds": 3600,
+                "scale_up_delay_seconds": 300,
+            },
+            "worker": {
+                "model": {
+                    "id": model_id,
+                    "model_version": {
+                        "id": model_version_id,
+                    },
+                    "user_id": user_id,
+                    "app_id": app_id,
+                }
+            },
+            "scheduling_choice": 4,  # "performance"
+            "nodepools": [
+                {
+                    "id": nodepool_id,
+                    "compute_cluster": {
+                        "id": compute_cluster_id,
+                        "user_id": cluster_user_id,
+                    },
+                }
+            ],
+            "visibility": {"gettable": 50},
+        }
+    }
+
+    try:
+        # Instantiate Nodepool and create the deployment
+        nodepool = Nodepool(nodepool_id=nodepool_id, user_id=user_id)
+        deployment = nodepool.create_deployment(
+            deployment_id=deployment_id, deployment_config=deployment_config
+        )
+
+        print(
+            f"✅ Deployment '{deployment_id}' successfully created for model '{model_id}' with version '{model_version_id}'."
+        )
+        return True
+    except Exception as e:
+        print(f"❌ Failed to create deployment '{deployment_id}': {e}")
+        return False
 
 
 def setup_deployment_for_model(builder):
     """
     Set up deployment for a model after upload.
 
-    :param builder: The ModelBuilder instance that has uploaded the model.
+    Args:
+        builder: The ModelBuilder instance that has uploaded the model.
     """
 
+    print("\n🚀 Model Deployment")
+    state = {
+        'uploaded': True,
+        'deployed': False,
+    }
     model = builder.config.get('model')
-    user_id = model.get('user_id')
-    app_id = model.get('app_id')
-    model_id = model.get('id')
-
-    # Set up the API client with the user's credentials
-    user = User(user_id=user_id, pat=builder.client.pat, base_url=builder.client.base)
-
-    # Step 1: Check for available compute clusters and let user choose or create a new one
-    logger.info("Checking for available compute clusters...")
-    compute_clusters = list(user.list_compute_clusters())
+    state.update(
+        {
+            'user_id': model.get('user_id'),
+            'app_id': model.get('app_id'),
+            'model_id': model.get('id'),
+            'model_version_id': builder.model_version_id,
+        }
+    )
 
-    compute_cluster = None
-    if compute_clusters:
-        logger.info("Available compute clusters:")
-        for i, cc in enumerate(compute_clusters):
-            logger.info(
-                f"{i + 1}. {cc.id} ({cc.description if hasattr(cc, 'description') else 'No description'})"
-            )
+    # Select compute options
+    compute_config = select_compute_option(user_id=state['user_id'])
 
-        choice = input(
-            f"Choose a compute cluster (1-{len(compute_clusters)}) or 'n' to create a new one: "
-        )
-        if choice.lower() == 'n':
-            create_new_cc = True
-        else:
-            try:
-                idx = int(choice) - 1
-                if 0 <= idx < len(compute_clusters):
-                    compute_cluster = compute_clusters[idx]
-                    create_new_cc = False
-                else:
-                    logger.info("Invalid choice. Creating a new compute cluster.")
-                    create_new_cc = True
-            except ValueError:
-                logger.info("Invalid choice. Creating a new compute cluster.")
-                create_new_cc = True
-    else:
-        logger.info("No compute clusters found.")
-        create_new_cc = True
-
-    if create_new_cc:
-        # Provide URL to create a new compute cluster
-        url_helper = ClarifaiUrlHelper()
-        compute_cluster_url = f"{url_helper.ui}/settings/compute/new"
-        logger.info(f"Please create a new compute cluster by visiting: {compute_cluster_url}")
-
-        # Ask if they want to open the URL in browser
-        open_browser = input(
-            "Do you want to open the compute cluster creation page in your browser? (y/n): "
+    # Get deployment configuration
+    print("\n⌨️  Enter Deployment Configuration:")
+    deployment_id = get_user_input(
+        "Enter deployment ID", default=f"deploy-{state['model_id']}-{uuid.uuid4().hex[:6]}"
+    )
+    min_replicas = int(get_user_input("Enter minimum replicas", default="1"))
+    max_replicas = int(get_user_input("Enter maximum replicas", default="5"))
+
+    print("\n⏳ Deploying model...")
+
+    # Retry logic for deployment
+    max_retries = 1
+    for attempt in range(max_retries):
+        success = deploy_model(
+            model_id=state['model_id'],
+            app_id=state['app_id'],
+            user_id=state['user_id'],
+            deployment_id=deployment_id,
+            model_version_id=state['model_version_id'],
+            nodepool_id=compute_config['nodepool_id'],
+            compute_cluster_id=compute_config['compute_cluster_id'],
+            cluster_user_id=compute_config['cluster_user_id'],
+            min_replicas=min_replicas,
+            max_replicas=max_replicas,
         )
-        if open_browser.lower() == 'y':
-            try:
-                webbrowser.open(compute_cluster_url)
-            except Exception as e:
-                logger.error(f"Failed to open browser: {e}")
 
-        input("After creating the compute cluster, press Enter to continue...")
+        if success:
+            state.update(
+                {
+                    'deployed': True,
+                    'deployment_id': deployment_id,
+                    'nodepool_id': compute_config['nodepool_id'],
+                }
+            )
+            print("Model deployed successfully! You can test it now.")
+            time.sleep(2)  # Give some time for the deployment to stabilize
+        elif attempt < max_retries - 1:
+            if get_yes_no_input("Deployment failed. Do you want to retry?", True):
+                continue
 
-        # Re-fetch the compute clusters list after user has created one
-        logger.info("Re-checking for available compute clusters...")
-        compute_clusters = list(user.list_compute_clusters())
+    if get_yes_no_input("\n🗑️ Do you want to backtrack and clean up?", True):
+        backtrack_workflow(state)
 
-        if not compute_clusters:
-            logger.info(
-                "No compute clusters found. Please make sure you have created a compute cluster and try again."
-            )
-            return
 
-        # Show the updated list and let user choose
-        logger.info("Available compute clusters:")
-        for i, cc in enumerate(compute_clusters):
-            logger.info(
-                f"{i + 1}. {cc.id} ({cc.description if hasattr(cc, 'description') else 'No description'})"
-            )
+def delete_model_deployment(deployment_id, user_id, nodepool_id=None):
+    """
+    Delete a model deployment on Clarifai platform.
 
-        choice = input(f"Choose a compute cluster (1-{len(compute_clusters)}): ")
-        try:
-            idx = int(choice) - 1
-            if 0 <= idx < len(compute_clusters):
-                compute_cluster = compute_clusters[idx]
-            else:
-                logger.info("Invalid choice. Aborting deployment setup.")
-                return
-        except ValueError:
-            logger.info("Invalid choice. Aborting deployment setup.")
-            return
+    Args:
+        deployment_id (str): The ID of the deployment to be deleted.
+        nodepool_id (str): The ID of the nodepool where the deployment resides.
+        user_id (str): The Clarifai user ID (usually owner of the deployment).
+    """
 
-    # Step 2: Check for available nodepools and let user choose or create a new one
-    logger.info(f"Checking for available nodepools in compute cluster '{compute_cluster.id}'...")
-    nodepools = list(compute_cluster.list_nodepools())
+    # Instantiate the Nodepool object with given IDs
+    nodepool = Nodepool(nodepool_id=nodepool_id, user_id=user_id)
+    # The delete_deployments method expects a list of deployment IDs
+    try:
+        nodepool.delete_deployments([deployment_id])
+        print(f"✅ Deployment '{deployment_id}' has been successfully deleted.")
+        return True
+    except Exception as e:
+        print(f"❌ Failed to delete deployment '{deployment_id}': {e}")
+        return False
 
-    nodepool = None
-    if nodepools:
-        logger.info("Available nodepools:")
-        for i, np in enumerate(nodepools):
-            logger.info(
-                f"{i + 1}. {np.id} ({np.description if hasattr(np, 'description') else 'No description'})"
-            )
 
-        choice = input(f"Choose a nodepool (1-{len(nodepools)}) or 'n' to create a new one: ")
-        if choice.lower() == 'n':
-            create_new_np = True
-        else:
-            try:
-                idx = int(choice) - 1
-                if 0 <= idx < len(nodepools):
-                    nodepool = nodepools[idx]
-                    create_new_np = False
-                else:
-                    logger.info("Invalid choice. Creating a new nodepool.")
-                    create_new_np = True
-            except ValueError:
-                logger.info("Invalid choice. Creating a new nodepool.")
-                create_new_np = True
-    else:
-        logger.info("No nodepools found in this compute cluster.")
-        create_new_np = True
-
-    if create_new_np:
-        # Provide URL to create a new nodepool
-        url_helper = ClarifaiUrlHelper()
-        nodepool_url = f"{url_helper.ui}/settings/compute/{compute_cluster.id}/nodepools/new"
-        logger.info(f"Please create a new nodepool by visiting: {nodepool_url}")
-
-        # Ask if they want to open the URL in browser
-        open_browser = input(
-            "Do you want to open the nodepool creation page in your browser? (y/n): "
-        )
-        if open_browser.lower() == 'y':
-            try:
-                webbrowser.open(nodepool_url)
-            except Exception as e:
-                logger.error(f"Failed to open browser: {e}")
+def delete_model_version(
+    model_url=None, model_id=None, app_id=None, user_id=None, model_version_id=None
+):
+    """
+    Delete a specific version of a model on Clarifai platform.
+    Args:
+        model_url (str): The full Clarifai model URL (optional if model_id is provided).
+        model_id (str): The ID of the model (optional if model_url is provided).
+        app_id (str): The ID of the application the model belongs to.
+        user_id (str): The ID of the user who owns the model.
+        model_version_id (str): The ID of the model version to be deleted.
+    """
+    if not model_version_id:
+        raise UserError("You must specify a model_version_id to delete.")
+    if model_url and model_id:
+        raise UserError("You can only specify one of url or model_id.")
+    if not model_url and not model_id:
+        raise UserError("You must specify one of url or model_id.")
+    if model_url:
+        user_id, app_id, _, model_id, _ = ClarifaiUrlHelper.split_clarifai_url(model_url)
+    model = Model(model_id=model_id, app_id=app_id, user_id=user_id)
+    try:
+        model.delete_version(version_id=model_version_id)
+        print(f"✅ Model version '{model_version_id}' successfully deleted.")
+        return True
+    except Exception as e:
+        print(f"❌ Failed to delete model version '{model_version_id}': {e}")
+        return False
 
-        input("After creating the nodepool, press Enter to continue...")
 
-        # Re-fetch the nodepools list after user has created one
-        logger.info(
-            f"Re-checking for available nodepools in compute cluster '{compute_cluster.id}'..."
-        )
-        nodepools = list(compute_cluster.list_nodepools())
+def backtrack_workflow(state):
+    """Handle backtracking when operations fail."""
+    print("\n🔄 Starting backtrack process...")
 
-        if not nodepools:
-            logger.info(
-                "No nodepools found. Please make sure you have created a nodepool in the selected compute cluster and try again."
+    # Delete deployment if it was created
+    if state.get('deployed') and state.get('deployment_id'):
+        if get_yes_no_input("Do you want to delete the deployment?", True):
+            success = delete_model_deployment(
+                deployment_id=state['deployment_id'],
+                user_id=state['user_id'],
+                nodepool_id=state.get('nodepool_id'),
             )
-            return
-
-        # Show the updated list and let user choose
-        logger.info("Available nodepools:")
-        for i, np in enumerate(nodepools):
-            logger.info(
-                f"{i + 1}. {np.id} ({np.description if hasattr(np, 'description') else 'No description'})"
+            if success:
+                state['deployed'] = False
+
+    # Delete model version if it was uploaded
+    if state.get('uploaded') and state.get('model_version_id'):
+        if get_yes_no_input("Do you want to delete the model version?", False):
+            success = delete_model_version(
+                model_id=state['model_id'],
+                app_id=state['app_id'],
+                user_id=state['user_id'],
+                model_version_id=state['model_version_id'],
             )
-
-        choice = input(f"Choose a nodepool (1-{len(nodepools)}): ")
-        try:
-            idx = int(choice) - 1
-            if 0 <= idx < len(nodepools):
-                nodepool = nodepools[idx]
-            else:
-                logger.info("Invalid choice. Aborting deployment setup.")
-                return
-        except ValueError:
-            logger.info("Invalid choice. Aborting deployment setup.")
-            return
-
-    # Step 3: Help create a new deployment by providing URL
-    # Provide URL to create a new deployment
-    url_helper = ClarifaiUrlHelper()
-    deployment_url = f"{url_helper.ui}/compute/deployments/create?computeClusterId={compute_cluster.id}&nodePoolId={nodepool.id}"
-    logger.info(f"Please create a new deployment by visiting: {deployment_url}")
-
-    # Ask if they want to open the URL in browser
-    open_browser = input(
-        "Do you want to open the deployment creation page in your browser? (y/n): "
-    )
-    if open_browser.lower() == 'y':
-        try:
-            webbrowser.open(deployment_url)
-        except Exception as e:
-            logger.error(f"Failed to open browser: {e}")
-
-    logger.info("After creating the deployment, your model will be ready for inference!")
+            if success:
+                state['uploaded'] = False
+                state['model_version_id'] = None

clarifai/runners/utils/method_signatures.py

@@ -23,6 +23,9 @@ from clarifai.runners.utils.serializers import (
     TupleSerializer,
 )
 
+# Reserved parameter name for protobuf response access
+RESERVED_PARAM_WITH_PROTO = 'with_proto'
+
 
 def build_function_signature(func):
     '''
@@ -45,6 +48,12 @@ def build_function_signature(func):
     input_sigs = []
     input_streaming = []
     for p in sig.parameters.values():
+        # Validate that user methods don't use reserved parameter names
+        if p.name == RESERVED_PARAM_WITH_PROTO:
+            raise ValueError(
+                f"Parameter name '{RESERVED_PARAM_WITH_PROTO}' is reserved and cannot be used in model methods. "
+                f"This parameter is automatically added by the framework to provide access to protobuf responses."
+            )
         model_type_field, _, streaming = build_variable_signature(p.name, p.annotation, p.default)
         input_sigs.append(model_type_field)
         input_streaming.append(streaming)

clarifai/utils/constants.py

@@ -66,6 +66,7 @@ DEFAULT_OLLAMA_MODEL_REPO_BRANCH = "ollama"
 DEFAULT_HF_MODEL_REPO_BRANCH = "huggingface"
 DEFAULT_LMSTUDIO_MODEL_REPO_BRANCH = "lmstudio"
 DEFAULT_VLLM_MODEL_REPO_BRANCH = "vllm"
+DEFAULT_SGLANG_MODEL_REPO_BRANCH = "sglang"
 DEFAULT_PYTHON_MODEL_REPO_BRANCH = "python"
 
 STATUS_OK = "200 OK"

clarifai/versions.py

@@ -1,3 +1,4 @@
+import importlib.util
 import os
 
 from clarifai import __version__
@@ -7,3 +8,25 @@ OS_VER = os.sys.platform
 PYTHON_VERSION = '.'.join(
     map(str, [os.sys.version_info.major, os.sys.version_info.minor, os.sys.version_info.micro])
 )
+
+
+def get_latest_version_from_pypi():
+    """
+    Fetch the latest version of the clarifai package from PyPI.
+
+    Returns:
+        str: The latest version string, or None if the request fails.
+    """
+    # Check if requests is installed
+    if importlib.util.find_spec("requests") is None:
+        return None
+
+    try:
+        import requests
+
+        response = requests.get("https://pypi.org/pypi/clarifai/json", timeout=5)
+        if response.status_code == 200:
+            return response.json().get("info", {}).get("version")
+        return None
+    except Exception:
+        return None

{clarifai-11.8.4.dist-info → clarifai-11.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clarifai
-Version: 11.8.4
+Version: 11.9.0
 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.8.2
-Requires-Dist: clarifai-protocol>=0.0.32
+Requires-Dist: clarifai-grpc>=11.9.8
+Requires-Dist: clarifai-protocol>=0.0.33
 Requires-Dist: numpy>=1.22.0
 Requires-Dist: tqdm>=4.65.0
 Requires-Dist: PyYAML>=6.0.1

{clarifai-11.8.4.dist-info → clarifai-11.9.0.dist-info}/RECORD

@@ -1,14 +1,14 @@
-clarifai/__init__.py,sha256=l80v8IYM70DFAKN9bwXRrDCRPmv0ykn84eJo3--0MWA,23
+clarifai/__init__.py,sha256=SXY1e-dnGDUvRtF27y_ABoyLFsY29JXPVQsa1fJZTDU,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/versions.py,sha256=E3_bdZmzlWko0Y0XSSpxDyNAU_7JRL533YsWv_ZrrEQ,843
 clarifai/cli/README.md,sha256=Rm0Sk61u7PrWQBgA6idv0R6ldJGhnVHSlIF2rVzRk8g,3428
 clarifai/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 clarifai/cli/__main__.py,sha256=7nPbLW7Jr2shkgMPvnxpn4xYGMvIcnqluJ69t9w4H_k,74
 clarifai/cli/base.py,sha256=FQEEmi3a9_LBOmM_-X4EYdpAmDK1UljTxrHOIIsOZbM,10696
 clarifai/cli/compute_cluster.py,sha256=8Xss0Obrp6l1XuxJe0luOqU_pf8vXGDRi6jyIe8qR6k,2282
 clarifai/cli/deployment.py,sha256=9C4I6_kyMxRkWl6h681wc79-3mAtDHtTUaxRv05OZMs,4262
-clarifai/cli/model.py,sha256=BN-hjSdpgju3kh6edi-0uBNVaroPxuSuMkgeevIQPPk,52722
+clarifai/cli/model.py,sha256=_tYdWdCpeXgbBZ-232DRPXYixci6o6p0Ig0LIH_vjwc,53004
 clarifai/cli/nodepool.py,sha256=H6OIdUW_EiyDUwZogzEDoYmVwEjLMsgoDlPyE7gjIuU,4245
 clarifai/cli/pipeline.py,sha256=bH7pnJGfjQIu_Y-f_zwKBFdPDTsBEEDtA2Oz9P6-Zj0,17129
 clarifai/cli/pipeline_step.py,sha256=dvoC2vAsDcxOCy88VV0X42PG22_7JSu9sfBVsk-Cix4,6133
@@ -16,7 +16,7 @@ clarifai/cli/templates/__init__.py,sha256=HbMlZuYOMyVJde73ijNAevmSRUpIttGlHdwyO4
 clarifai/cli/templates/model_templates.py,sha256=OU3qgYXSITo5qp0mkRiisXOMNhj6wNKWlZUFnAFZfGE,10090
 clarifai/cli/templates/pipeline_step_templates.py,sha256=w1IJghF_4wWyEmHR1925N0hpGKocy3G7ezhxTH-0XCc,1716
 clarifai/cli/templates/pipeline_templates.py,sha256=iLVxkmd0usc7jervTZTFzLwRVVF_623RszGW-oIuPDw,4234
-clarifai/client/__init__.py,sha256=MWEG_jTGn6UWbGCznsZxObJ5h65k2igD1462qID2pgI,840
+clarifai/client/__init__.py,sha256=l3KOOnD7S6FmSLLwkbZB0FjvOWbWjqdSnnM1Pt56nCY,1051
 clarifai/client/app.py,sha256=8_Y5esptlFSGW2WS0uly9IBop37hJVpxnhs-vBIZrtc,47205
 clarifai/client/base.py,sha256=eztsqJyQkaXAUNVBBhAhUNlDwgHTOzjPL1KcjblqWGU,12088
 clarifai/client/compute_cluster.py,sha256=q-JuBai4pKpSeDAn-P61IKyGjizX-IV-O5huWAYx5DU,10279
@@ -25,7 +25,7 @@ clarifai/client/deployment.py,sha256=QBf0tzkKBEpzNgmOEmWUJMOlVWdFEFc70Y44o8y75Gs
 clarifai/client/input.py,sha256=jpX47qwn7aUBBIEuSSLHF5jk70XaWEh0prD065c9b-E,51205
 clarifai/client/lister.py,sha256=1YEm2suNxPaJO4x9V5szgD_YX6N_00vgSO-7m0HagY8,2208
 clarifai/client/model.py,sha256=uOnR1GPOJUoNWDmd_Ja9XJq8oRPa1frTxBQ_ypQXc8Q,93518
-clarifai/client/model_client.py,sha256=8N8dRqb5zfFCNxq-jc-YSL19tgS8PpevnxY69G2YzCE,38280
+clarifai/client/model_client.py,sha256=bO9gMIvGRPSrOUKvjMXJmW4-1tb8tHYiHzvaJCZanIk,39609
 clarifai/client/module.py,sha256=pTcTmR48-VQRCEj3PJK_ZT5YTsYfZDbEjxwJ43rcLMM,4753
 clarifai/client/nodepool.py,sha256=QDJOMOYrZAG962u-MZWjXOZifjWK8hDgS2zoUn59dZU,16751
 clarifai/client/pipeline.py,sha256=y4swF2LsTag8l_-CT1jN4RXEwp_YYYkO6P_n97Cq1kg,15961
@@ -77,7 +77,7 @@ clarifai/runners/dockerfile_template/Dockerfile.template,sha256=nEnIMqzhAXDbd0Ht
 clarifai/runners/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 clarifai/runners/models/dummy_openai_model.py,sha256=LfAJu173uTEYsN6xpaJ6TyimohyTooX16H6YYk9qVLs,8636
 clarifai/runners/models/mcp_class.py,sha256=RdKn7rW4vYol0VRDZiLTSMfkqjLhO1ijXAQ0Rq0Jfnw,6647
-clarifai/runners/models/model_builder.py,sha256=8sgjI9l-4B4-8LxE7gD2POBw5t1ME86Qbb41ZD6qBi8,80827
+clarifai/runners/models/model_builder.py,sha256=5c-3d6J1FnN-5LPFKP2yxuAdPY_LjdHQCkNrqAsBdMA,86050
 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=jzq72S0Fz3C0rt9OSyZxok2EN6f_-K5z-0TmupdiQP4,14421
@@ -94,7 +94,7 @@ clarifai/runners/utils/code_script.py,sha256=-6IgNruIMTYLKJG8EqVWSaZR7lFRBoQ4ufJ
 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=hQwdRKRLgrunDzLTiqjz2qVdxiL8WQ04PUSwrh-JWZ0,12077
-clarifai/runners/utils/method_signatures.py,sha256=qdHaO8ZIgP6BBXXMhMPhcQ46dse-XMP2t4VJCNG7O3Q,18335
+clarifai/runners/utils/method_signatures.py,sha256=wOQnt3WVTnLBg0fhq2AxIb-2zdorYZ5aZPqlIwAybz8,18825
 clarifai/runners/utils/model_utils.py,sha256=MCYhV_00anptIO1Qtxgzn3DlGI2UHV0ESFT3wLNcAMM,6413
 clarifai/runners/utils/openai_convertor.py,sha256=ZlIrvvfHttD_DavLvmKZdL8gNq_TQvQtZVnYamwdWz4,8248
 clarifai/runners/utils/pipeline_validation.py,sha256=GFgFbrlS0UvGXcYTS84CyX7hIVU2CUNVQiMnCAjNfhw,6444
@@ -107,7 +107,7 @@ clarifai/urls/helper.py,sha256=z6LnLGgLHxD8scFtyRdxqYIRJNhxqPkfLe53UtTLUBY,11727
 clarifai/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 clarifai/utils/cli.py,sha256=3PhMdb84mjrwcxkRuhxX71UXBgh-Lcave7xURJf5inE,16548
 clarifai/utils/config.py,sha256=dENYtcWW7Il5MInvIaYe0MZn0hW1fbIb0Lzk8rQ_geQ,7671
-clarifai/utils/constants.py,sha256=2LGYqi55-YaHLfFNLZSrZNuChJ8rm7_voBysSFtoQF8,2541
+clarifai/utils/constants.py,sha256=zSQXQh8oFXuiZLWdnvm424g_llVY0QnyjKLBx3PSf2Y,2585
 clarifai/utils/hashing.py,sha256=z2hHt4sDvGyqNbnOay0F2i3K_PjyX-J24IEytszyYsA,3761
 clarifai/utils/logging.py,sha256=0we53uTqUvzrulC86whu-oeWNxn1JjJL0OQ98Bwf9vo,15198
 clarifai/utils/misc.py,sha256=ATj4RR6S06GeLE0X4tMU4bmTz4Sz4j2WemTddsnSfMI,23458
@@ -122,9 +122,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.8.4.dist-info/licenses/LICENSE,sha256=mUqF_d12-qE2n41g7C5_sq-BMLOcj6CNN-jevr15YHU,555
-clarifai-11.8.4.dist-info/METADATA,sha256=mNT5gLQe6QyrWy_kKhF-XCSAqR2F932MDYyTEy8aPQ4,23193
-clarifai-11.8.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-clarifai-11.8.4.dist-info/entry_points.txt,sha256=X9FZ4Z-i_r2Ud1RpZ9sNIFYuu_-9fogzCMCRUD9hyX0,51
-clarifai-11.8.4.dist-info/top_level.txt,sha256=wUMdCQGjkxaynZ6nZ9FAnvBUCgp5RJUVFSy2j-KYo0s,9
-clarifai-11.8.4.dist-info/RECORD,,
+clarifai-11.9.0.dist-info/licenses/LICENSE,sha256=mUqF_d12-qE2n41g7C5_sq-BMLOcj6CNN-jevr15YHU,555
+clarifai-11.9.0.dist-info/METADATA,sha256=yfVt_BCrRW5q3GB519QmYxbqwJgbAGIx_xLWQJVzUoA,23193
+clarifai-11.9.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+clarifai-11.9.0.dist-info/entry_points.txt,sha256=X9FZ4Z-i_r2Ud1RpZ9sNIFYuu_-9fogzCMCRUD9hyX0,51
+clarifai-11.9.0.dist-info/top_level.txt,sha256=wUMdCQGjkxaynZ6nZ9FAnvBUCgp5RJUVFSy2j-KYo0s,9
+clarifai-11.9.0.dist-info/RECORD,,