clarifai 11.5.0__py3-none-any.whl → 11.5.2__py3-none-any.whl

clarifai/__init__.py

@@ -1 +1 @@
-__version__ = "11.5.0"
+__version__ = "11.5.2"

clarifai/cli/model.py

@@ -520,6 +520,10 @@ def local_dev(ctx, model_path):
 
         try:
             runner = nodepool.runner(runner_id)
+            # ensure the deployment is using the latest version.
+            if runner.worker.model.model_version.id != version.id:
+                nodepool.delete_runners([runner_id])
+                raise AttributeError("Deleted runner that was for an old model version ID.")
         except Exception as e:
             raise AttributeError("Runner not found in nodepool.") from e
     except AttributeError:
@@ -549,6 +553,10 @@ def local_dev(ctx, model_path):
         deployment_id = DEFAULT_LOCAL_DEV_DEPLOYMENT_ID
     try:
         deployment = nodepool.deployment(deployment_id)
+        # ensure the deployment is using the latest version.
+        if deployment.worker.model.model_version.id != version.id:
+            nodepool.delete_deployments([deployment_id])
+            raise Exception("Deleted deployment that was for an old model version ID.")
         try:
             deployment_id = ctx.obj.current.deployment_id
         except AttributeError:  # doesn't exist in context but does in API then update the context.
@@ -576,6 +584,7 @@ def local_dev(ctx, model_path):
                             },
                         }
                     ],
+                    "deploy_latest_version": True,
                 }
             },
         )

clarifai/client/app.py

@@ -470,8 +470,8 @@ class App(Lister, BaseClient):
                 model = self.model(
                     model_id=node['model']['model_id'],
                     model_version={"id": node['model'].get('model_version_id', "")},
-                    user_id=node['model'].get('user_id', ""),
-                    app_id=node['model'].get('app_id', ""),
+                    user_id=node['model'].get('user_id', self.user_app_id.user_id),
+                    app_id=node['model'].get('app_id', self.user_app_id.app_id),
                 )
             except Exception as e:
                 if "Model does not exist" in str(e):

clarifai/client/auth/helper.py

@@ -1,7 +1,6 @@
 import os
 import urllib.request
 from typing import Any, Dict
-from urllib.parse import urlparse
 
 from clarifai_grpc.channel.clarifai_channel import ClarifaiChannel
 from clarifai_grpc.grpc.api import resources_pb2, service_pb2_grpc
@@ -42,28 +41,31 @@ def https_cache(cache: dict, url: str) -> str:
     elif url.startswith("http://"):
         url = url.replace("http://", "")
         cache[url] = HTTP
-    elif url not in cache:
+    elif url.endswith(":443"):
+        # If it ends with :443 then we know it's https.
+        # trim it off the right
+        url = url[:-4]
+        cache[url] = HTTPS
+    elif url.find('.clarifai.com') >= 0:
         # We know our endpoints are https.
-        host_name = urlparse(url).hostname
-        if host_name and host_name.endswith(".clarifai.com"):
-            cache[url] = HTTPS
-        else:  # need to test it.
-            try:  # make request to https endpoint.
-                urllib.request.urlopen("https://%s/v2/auth/methods" % url, timeout=1)
-                cache[url] = HTTPS  # cache it.
-            except Exception as e:
-                if "SSL" in str(e):  # if ssl error then we know it's http.
-                    cache[url] = HTTP
-                    # For http urls we need host:port format.
-                    if ":" not in url:
-                        raise Exception(
-                            "When providing an insecure url it must have both host:port format"
-                        )
-                else:
+        cache[url] = HTTPS
+    elif url not in cache:
+        # need to test ones that we don't have in the cache yet.
+        try:  # make request to https endpoint.
+            urllib.request.urlopen("https://%s/v2/auth/methods" % url, timeout=5)
+            cache[url] = HTTPS  # cache it.
+        except Exception as e:
+            if "SSL" in str(e):  # if ssl error then we know it's http.
+                cache[url] = HTTP
+                # For http urls we need host:port format.
+                if ":" not in url:
                     raise Exception(
-                        "Could not get a valid response from url: %s, is the API running there?"
-                        % url
-                    ) from e
+                        "When providing an insecure url it must have both host:port format"
+                    )
+            else:
+                raise Exception(
+                    "Could not get a valid response from url: %s, is the API running there?" % url
+                ) from e
     return url
 
 

clarifai/runners/__init__.py

@@ -1,11 +1,11 @@
-from .models.model_builder import ModelBuilder
+from .models.mcp_class import MCPModelClass
 from .models.model_class import ModelClass
 from .models.model_runner import ModelRunner
 from .models.openai_class import OpenAIModelClass
 
 __all__ = [
     "ModelRunner",
-    "ModelBuilder",
     "ModelClass",
+    "MCPModelClass",
     "OpenAIModelClass",
 ]

clarifai/runners/dockerfile_template/Dockerfile.template

@@ -3,9 +3,13 @@ FROM --platform=$TARGETPLATFORM ${FINAL_IMAGE} as final
 
 COPY --link requirements.txt /home/nonroot/requirements.txt
 
+ENV VIRTUAL_ENV=/venv
+ENV PATH="/home/nonroot/.local/bin:$VIRTUAL_ENV/bin:$PATH"
+
+
 # Update clarifai package so we always have latest protocol to the API. Everything should land in /venv
-RUN ["pip", "install", "--no-cache-dir", "-r", "/home/nonroot/requirements.txt"]
-RUN ["pip", "show", "clarifai"]
+RUN ["uv", "pip", "install", "--no-cache-dir", "-r", "/home/nonroot/requirements.txt"]
+RUN ["uv", "pip", "show", "--no-cache-dir", "clarifai"]
 
 # Set the NUMBA cache dir to /tmp
 # Set the TORCHINDUCTOR cache dir to /tmp

clarifai/runners/models/mcp_class.py

@@ -2,14 +2,13 @@
 
 import asyncio
 import json
-from typing import Any
-
-from fastmcp import Client, FastMCP  # use fastmcp v2 not the built in mcp
-from mcp import types
-from mcp.shared.exceptions import McpError
+from typing import TYPE_CHECKING, Any
 
 from clarifai.runners.models.model_class import ModelClass
 
+if TYPE_CHECKING:
+    from fastmcp import FastMCP
+
 
 class MCPModelClass(ModelClass):
     """Base class for wrapping FastMCP servers as a model running in Clarfai. This handles
@@ -19,10 +18,17 @@ class MCPModelClass(ModelClass):
     """
 
     def load_model(self):
+        try:
+            from fastmcp import Client
+        except ImportError:
+            raise ImportError(
+                "fastmcp package is required to use MCP functionality. "
+                "Install it with: pip install fastmcp"
+            )
         # in memory transport provided in fastmcp v2 so we can easily use the client functions.
         self.client = Client(self.get_server())
 
-    def get_server(self) -> FastMCP:
+    def get_server(self) -> 'FastMCP':
         """Required method for each subclass to implement to return the FastMCP server to use."""
         raise NotImplementedError("Subclasses must implement get_server() method")
 
@@ -32,6 +38,8 @@ class MCPModelClass(ModelClass):
         return it's response.
 
         """
+        from mcp import types
+        from mcp.shared.exceptions import McpError
 
         async def send_notification(client_message: types.ClientNotification) -> None:
             async with self.client:

clarifai/runners/models/model_builder.py

@@ -4,9 +4,11 @@ import inspect
 import os
 import re
 import shutil
+import subprocess
 import sys
 import tarfile
 import time
+import webbrowser
 from string import Template
 from unittest.mock import MagicMock
 
@@ -16,6 +18,7 @@ from clarifai_grpc.grpc.api.status import status_code_pb2
 from google.protobuf import json_format
 
 from clarifai.client.base import BaseClient
+from clarifai.client.user import User
 from clarifai.runners.models.model_class import ModelClass
 from clarifai.runners.utils.const import (
     AMD_PYTHON_BASE_IMAGE,
@@ -61,7 +64,12 @@ def is_related(object_class, main_class):
 class ModelBuilder:
     DEFAULT_CHECKPOINT_SIZE = 50 * 1024**3  # 50 GiB
 
-    def __init__(self, folder: str, validate_api_ids: bool = True, download_validation_only=False):
+    def __init__(
+        self,
+        folder: str,
+        validate_api_ids: bool = True,
+        download_validation_only: bool = False,
+    ):
         """
         :param folder: The folder containing the model.py, config.yaml, requirements.txt and
         checkpoints.
@@ -563,6 +571,42 @@ class ModelBuilder:
                 dependencies_version[dependency] = version if version else None
         return dependencies_version
 
+    def _validate_requirements(self, python_version):
+        """here we use uv pip compile to validate the requirements.txt file
+        and ensure that the dependencies are compatible with each other prior to uploading
+        """
+        if not os.path.exists(os.path.join(self.folder, 'requirements.txt')):
+            raise FileNotFoundError(
+                "requirements.txt not found in the folder, please provide a valid requirements.txt file"
+            )
+        path = os.path.join(self.folder, 'requirements.txt')
+        # run the f"uv pip compile {path} --universal" command to validate the requirements.txt file
+        if not shutil.which('uv'):
+            raise Exception(
+                "uv command not found, please install uv to validate the requirements.txt file"
+            )
+        logger.info(f"Setup: Validating requirements.txt file at {path} using uv pip compile")
+        # Don't log the output of the comment unless it errors.
+        result = subprocess.run(
+            f"uv pip compile {path} --universal --python {python_version} --no-header  --no-emit-index-url",
+            shell=True,
+            text=True,
+            capture_output=True,
+            check=False,
+        )
+        if result.returncode != 0:
+            logger.error(f"Error validating requirements.txt file: {result.stderr}")
+            logger.error(
+                "Failed to validate the requirements.txt file, please check the file for errors. Note this can happen if the machine you're upload from has different python version, accelerator, etc. from the desired machine you want to upload to."
+            )
+            logger.error("Output: " + result.stdout)
+            # If we have an error, raise an exception.
+            return False
+        else:
+            logger.info("Setup: Requirements.txt file validated successfully")
+            # If we have no error, we can just return.
+            return True
+
     def _is_amd(self):
         """
         Check if the model is AMD or not.
@@ -582,11 +626,50 @@ class ModelBuilder:
                 "Both AMD and NVIDIA GPUs are specified in the config file, please use only one type of GPU."
             )
         if is_amd_gpu:
-            logger.info("Using AMD base image to build the Docker image and upload the model")
+            logger.info(
+                "Setup: Using AMD base image to build the Docker image and upload the model"
+            )
         elif is_nvidia_gpu:
-            logger.info("Using NVIDIA base image to build the Docker image and upload the model")
+            logger.info(
+                "Setup: Using NVIDIA base image to build the Docker image and upload the model"
+            )
         return is_amd_gpu
 
+    def _lint_python_code(self):
+        """
+        Lint the python code in the model.py file using flake8.
+        This will help catch any simple bugs in the code before uploading it to the API.
+        """
+        if not shutil.which('ruff'):
+            raise Exception("ruff command not found, please install ruff to lint the python code")
+        # List all the python files in the /1/ folder recursively and lint them.
+        python_files = []
+        for root, _, files in os.walk(os.path.join(self.folder, '1')):
+            for file in files:
+                if file.endswith('.py'):
+                    python_files.append(os.path.join(root, file))
+        if not python_files:
+            logger.info("No Python files found to lint, skipping linting step.")
+        else:
+            logger.info(f"Setup: Linting Python files: {python_files}")
+        # Run ruff to lint the python code.
+        command = "ruff check --select=F"
+        result = subprocess.run(
+            f"{command} {' '.join(python_files)}",
+            shell=True,
+            text=True,
+            capture_output=True,
+            check=False,
+        )
+        if result.returncode != 0:
+            logger.error(f"Error linting Python code: {result.stderr}")
+            logger.error("Output: " + result.stdout)
+            logger.error(
+                f"Failed to lint the Python code, please check the code for errors using '{command}' so you don't have simple errors in your code prior to upload."
+            )
+        else:
+            logger.info("Setup: Python code linted successfully, no errors found.")
+
     def create_dockerfile(self):
         dockerfile_template = os.path.join(
             os.path.dirname(os.path.dirname(__file__)),
@@ -609,14 +692,21 @@ class ModelBuilder:
                 )
 
             logger.info(
-                f"Using Python version {python_version} from the config file to build the Dockerfile"
+                f"Setup: Using Python version {python_version} from the config file to build the Dockerfile"
             )
         else:
             logger.info(
-                f"Python version not found in the config file, using default Python version: {DEFAULT_PYTHON_VERSION}"
+                f"Setup: Python version not found in the config file, using default Python version: {DEFAULT_PYTHON_VERSION}"
             )
             python_version = DEFAULT_PYTHON_VERSION
 
+        # Before we bother even picking the right base image, let's use uv to validate
+        # that the requirements.txt file is valid and compatible.
+        self._validate_requirements(python_version)
+
+        # Make sure any python code will not have simple bugs by linting it first.
+        self._lint_python_code()
+
         # Parse the requirements.txt file to determine the base image
         dependencies = self._parse_requirements()
 
@@ -637,7 +727,7 @@ class ModelBuilder:
                         )
                     if not torch_version:
                         logger.info(
-                            f"torch version not found in requirements.txt, using the default version {DEFAULT_AMD_TORCH_VERSION}"
+                            f"Setup: torch version not found in requirements.txt, using the default version {DEFAULT_AMD_TORCH_VERSION}"
                         )
                         torch_version = DEFAULT_AMD_TORCH_VERSION
                     if torch_version not in [DEFAULT_AMD_TORCH_VERSION]:
@@ -651,7 +741,7 @@ class ModelBuilder:
                     python_version=python_version,
                     gpu_version=gpu_version,
                 )
-                logger.info("Using vLLM base image to build the Docker image")
+                logger.info("Setup: Using vLLM base image to build the Docker image")
             elif 'torch' in dependencies:
                 torch_version = dependencies['torch']
                 if python_version != DEFAULT_PYTHON_VERSION:
@@ -675,7 +765,7 @@ class ModelBuilder:
                     gpu_version=gpu_version,
                 )
                 logger.info(
-                    f"Using Torch version {torch_version} base image to build the Docker image"
+                    f"Setup: Using Torch version {torch_version} base image to build the Docker image"
                 )
         else:
             final_image = PYTHON_BASE_IMAGE.format(python_version=python_version)
@@ -684,6 +774,8 @@ class ModelBuilder:
                 torch_version = dependencies['torch']
                 # Sort in reverse so that newer cuda versions come first and are preferred.
                 for image in sorted(AVAILABLE_TORCH_IMAGES, reverse=True):
+                    if image.find('rocm') >= 0:
+                        continue  # skip ROCm images as those are handled above.
                     if torch_version in image and f'py{python_version}' in image:
                         # like cu124, rocm6.3, etc.
                         gpu_version = image.split('-')[-1]
@@ -693,7 +785,7 @@ class ModelBuilder:
                             gpu_version=gpu_version,
                         )
                         logger.info(
-                            f"Using Torch version {torch_version} base image to build the Docker image"
+                            f"Setup: Using Torch version {torch_version} base image to build the Docker image"
                         )
                         break
         if 'clarifai' not in dependencies:
@@ -1109,4 +1201,208 @@ def upload_model(folder, stage, skip_dockerfile):
         )
 
     input("Press Enter to continue...")
-    builder.upload_model_version()
+    model_version = builder.upload_model_version()
+
+    # Ask user if they want to deploy the model
+    deploy_model = input("Do you want to deploy the model? (y/n): ")
+    if deploy_model.lower() != 'y':
+        logger.info("Model uploaded successfully. Skipping deployment setup.")
+        return
+
+    # Setup deployment for the uploaded model
+    setup_deployment_for_model(builder)
+
+
+def setup_deployment_for_model(builder):
+    """
+    Set up deployment for a model after upload.
+
+    :param builder: The ModelBuilder instance that has uploaded the model.
+    """
+
+    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())
+
+    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'})"
+            )
+
+        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): "
+        )
+        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...")
+
+        # 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 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'})"
+            )
+
+        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
+
+    # 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())
+
+    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}")
+
+        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())
+
+        if not nodepools:
+            logger.info(
+                "No nodepools found. Please make sure you have created a nodepool in the selected compute cluster and try again."
+            )
+            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'})"
+            )
+
+        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}/settings/compute/deployments/new?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!")
+    logger.info(f"You can always return to view your deployments at: {deployment_url}")

clarifai/runners/utils/code_script.py

@@ -76,7 +76,7 @@ client = OpenAI(
 response = client.chat.completions.create(
     model="%s",
     messages=[
-        {"role": "developer", "content": "Talk like a pirate."},
+        {"role": "system", "content": "Talk like a pirate."},
         {
             "role": "user",
             "content": "How do I check if a Python object is an instance of a class?",

clarifai/runners/utils/const.py

@@ -2,9 +2,9 @@ import os
 
 registry = os.environ.get('CLARIFAI_BASE_IMAGE_REGISTRY', 'public.ecr.aws/clarifai-models')
 
-GIT_SHA = "b8ae56bf3b7c95e686ca002b07ca83d259c716eb"
+GIT_SHA = "42938da8e33b0f37ee7db16b83631da94c2348b9"
 
-AMD_GIT_SHA = "81e942130173f54927e7c9a65aabc7e32780616d"
+AMD_GIT_SHA = "42938da8e33b0f37ee7db16b83631da94c2348b9"
 
 PYTHON_BASE_IMAGE = registry + '/python-base:{python_version}-' + GIT_SHA
 TORCH_BASE_IMAGE = registry + '/torch:{torch_version}-py{python_version}-{gpu_version}-' + GIT_SHA
@@ -20,7 +20,7 @@ AMD_VLLM_BASE_IMAGE = (
 # List of available python base images
 AVAILABLE_PYTHON_IMAGES = ['3.11', '3.12']
 
-DEFAULT_PYTHON_VERSION = 3.12
+DEFAULT_PYTHON_VERSION = '3.12'
 
 DEFAULT_AMD_TORCH_VERSION = '2.8.0.dev20250511+rocm6.4'
 

clarifai/workflows/export.py

@@ -16,12 +16,9 @@ def clean_up_unused_keys(wf: dict):
             new_wf["model"] = {
                 "model_id": wf["model"]["id"],
                 "model_version_id": wf["model"]["model_version"]["id"],
+                "user_id": wf["model"]["user_id"],
+                "app_id": wf["model"]["app_id"],
             }
-            # If the model is not from clarifai main, add the app_id and user_id to the model dict.
-            if wf["model"]["user_id"] != "clarifai" and wf["model"]["app_id"] != "main":
-                new_wf["model"].update(
-                    {"app_id": wf["model"]["app_id"], "user_id": wf["model"]["user_id"]}
-                )
         elif isinstance(val, dict):
             new_wf[key] = clean_up_unused_keys(val)
         elif isinstance(val, list):

{clarifai-11.5.0.dist-info → clarifai-11.5.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clarifai
-Version: 11.5.0
+Version: 11.5.2
 Home-page: https://github.com/Clarifai/clarifai-python
 Author: Clarifai
 Author-email: support@clarifai.com
@@ -31,6 +31,8 @@ Requires-Dist: fsspec>=2024.6.1
 Requires-Dist: click>=8.1.7
 Requires-Dist: requests>=2.32.3
 Requires-Dist: aiohttp>=3.10.0
+Requires-Dist: uv==0.7.12
+Requires-Dist: ruff==0.11.4
 Provides-Extra: all
 Requires-Dist: pycocotools>=2.0.7; extra == "all"
 Dynamic: author

{clarifai-11.5.0.dist-info → clarifai-11.5.2.dist-info}/RECORD

@@ -1,4 +1,4 @@
-clarifai/__init__.py,sha256=89g_4HXr4XouZfNDdwEbm-Xwu06Vvu-EUBmo-baEVQQ,23
+clarifai/__init__.py,sha256=a5pEEaKahMvZwBR_7X6j8C953yywB3wOFeS2bzAe50o,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
@@ -8,11 +8,11 @@ clarifai/cli/__main__.py,sha256=7nPbLW7Jr2shkgMPvnxpn4xYGMvIcnqluJ69t9w4H_k,74
 clarifai/cli/base.py,sha256=mzfAHRhon6tKntpxk241GD-Sjrb2-V99nAOasElLuuw,8254
 clarifai/cli/compute_cluster.py,sha256=8Xss0Obrp6l1XuxJe0luOqU_pf8vXGDRi6jyIe8qR6k,2282
 clarifai/cli/deployment.py,sha256=9C4I6_kyMxRkWl6h681wc79-3mAtDHtTUaxRv05OZMs,4262
-clarifai/cli/model.py,sha256=9sJ5p4TJc41vOeeFoMC3e8cciscSU7TmvAgW0wfO54U,30191
+clarifai/cli/model.py,sha256=RYo0ZGdTXG8e72QDH4-w5_73aa30sNHE5o2f1pWZpK0,30793
 clarifai/cli/model_templates.py,sha256=_ZonIBnY9KKSJY31KZbUys_uN_k_Txu7Dip12KWfmSU,9633
 clarifai/cli/nodepool.py,sha256=H6OIdUW_EiyDUwZogzEDoYmVwEjLMsgoDlPyE7gjIuU,4245
 clarifai/client/__init__.py,sha256=NhpNFRJY6mTi8ca-5hUeTEmYeDKHDNXY48FN63pDuos,703
-clarifai/client/app.py,sha256=D0FG9v07g1dExLnQsYt0OQjsJCkVvuw76BOpcqaCzfM,41380
+clarifai/client/app.py,sha256=1M9XDsPWIEsj0g-mgIeZ9Mvkt85UHSbrv6pEr-QKfNg,41423
 clarifai/client/base.py,sha256=zOmB5HJP_-NmF2BPka14W7VUeJ1OF-fNxeacLsaRj3E,8775
 clarifai/client/compute_cluster.py,sha256=ViPyh-FibXL1J0ypsVOTaQnR1ymKohmZEuA13RwA-hc,10254
 clarifai/client/dataset.py,sha256=OgdpZkQ_vYmRxL8-qphcNozpvPV1bWTlte9Jv6UkKb8,35299
@@ -28,7 +28,7 @@ clarifai/client/search.py,sha256=3LLfATrdU43a0mRNITmJV-E53bhfafZkYsbwkTtlnyU,156
 clarifai/client/user.py,sha256=_G_x3P6IJqtRqI2r0HDAhSfQJmqWgEfwEVmRTOJISbw,19052
 clarifai/client/workflow.py,sha256=Bqh8lAmJcSbviJebckchTxucYlU11UQEhFSov7elpsk,13417
 clarifai/client/auth/__init__.py,sha256=7EwR0NrozkAUwpUnCsqXvE_p0wqx_SelXlSpKShKJK0,136
-clarifai/client/auth/helper.py,sha256=kHBi8GTX19EUiD9n_QgCqilv127TDIpP0_o5MMtzFdY,15167
+clarifai/client/auth/helper.py,sha256=T-j2hFoczdbWft5p72aU3vTOEr9H8xOOZlBXA5JBJL0,15181
 clarifai/client/auth/register.py,sha256=pyY-Kg_64WpN6rXz1SyEzfqL14BS4yADtuYMxLJ4jx4,554
 clarifai/client/auth/stub.py,sha256=pU4FYeghooCBZmCRyNTdDfJaVe4WyeRBqE3xVwfmMTY,5388
 clarifai/constants/base.py,sha256=ogmFSZYoF0YhGjHg5aiOc3MLqPr_poKAls6xaD0_C3U,89
@@ -64,13 +64,13 @@ clarifai/modules/style.css,sha256=j7FNPZVhLPj35vvBksAJ90RuX5sLuqzDR5iM2WIEhiA,60
 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=CQhpUOj_x-oV9xEUKdL-hi3A1BQAtPUv-FFOev4a96w,281
+clarifai/runners/__init__.py,sha256=wXLaSljH7qLeJCrZdKEnlQh2tNqTQAIZKWOu2rZ6wGs,279
 clarifai/runners/server.py,sha256=9qVAs8pRHmtyY0RCNIQ1uP8nqDADIFZ03LnkoDt1h4U,4692
-clarifai/runners/dockerfile_template/Dockerfile.template,sha256=5cjv7U8PmWa3DB_5B1CqSYh_6GE0E0np52TIAa7EIDE,2312
+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=7uwCMade0LMMBq7vczhPf4Kxdmh8Rj0R7Pg3pPxYdjQ,6386
-clarifai/runners/models/model_builder.py,sha256=PiqPyTGPSKsYvOQNpBzs4e1_wuEbtE-P3yEkLE4Py10,49231
+clarifai/runners/models/mcp_class.py,sha256=RdKn7rW4vYol0VRDZiLTSMfkqjLhO1ijXAQ0Rq0Jfnw,6647
+clarifai/runners/models/model_builder.py,sha256=s5TpCnLeiYLBgWHlCT6x6vpwTGX52oywViU6xDRl0MU,61599
 clarifai/runners/models/model_class.py,sha256=-euUF-eHUi4KXR_e1pIwvToDZ13CM6TSz2FolzildjM,16069
 clarifai/runners/models/model_run_locally.py,sha256=6-6WjEKc0ba3gAv4wOLdMs2XOzS3b-2bZHJS0wdVqJY,20088
 clarifai/runners/models/model_runner.py,sha256=SccX-RxTgruSpQaM21uMSl-z1x6fOa13fQZMQW8NNRY,7297
@@ -79,8 +79,8 @@ clarifai/runners/models/openai_class.py,sha256=aXlk5W6LWkh-A4eZYi74DeLW0i_86_9DY
 clarifai/runners/models/visual_classifier_class.py,sha256=1ZoLfCT2crrgRbejjTMAIwpTRgQMiH9N9yflOVpFxSg,2721
 clarifai/runners/models/visual_detector_class.py,sha256=ky4oFAkGCKPpGPdgaOso-n6D3HcmnbKee_8hBsNiV8U,2883
 clarifai/runners/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-clarifai/runners/utils/code_script.py,sha256=Ae1u2686ycxDGdYXnPzVvDxhc5i-JZ_A4GDpq0xHvjo,12772
-clarifai/runners/utils/const.py,sha256=Q4Ps6gIEJCyTdQCfmT6PaS61WHmhT25XigV1NugWz-E,1544
+clarifai/runners/utils/code_script.py,sha256=1n525IhMEdWlr9jBUG76tMa42piZtl0CmWYBmkvu368,12769
+clarifai/runners/utils/const.py,sha256=B0TnmVgjh5NlsXIkowrlgz2QdsgLj4a-gu4Igc9ukCo,1546
 clarifai/runners/utils/data_utils.py,sha256=HRpMYR2O0OiDpXXhOManLHTeomC4bFnXMHVAiT_12yE,20856
 clarifai/runners/utils/loader.py,sha256=K5Y8MPbIe5STw2gDnrL8KqFgKNxEo7bz-RV0ip1T4PM,10900
 clarifai/runners/utils/method_signatures.py,sha256=qdHaO8ZIgP6BBXXMhMPhcQ46dse-XMP2t4VJCNG7O3Q,18335
@@ -104,12 +104,12 @@ clarifai/utils/evaluation/helpers.py,sha256=0t6eIDXeZEoiVvnmHTnsIF_-v4BzrQW1hFaq
 clarifai/utils/evaluation/main.py,sha256=N_sfRuMjHrUeuWN0Pzms65M1PbkQkgYg3WoQVaDR1Jw,17764
 clarifai/utils/evaluation/testset_annotation_parser.py,sha256=Nmodfi5BYFYEbybWcC8tmU5-wtwRBsWIbnpd3OvKSmA,5414
 clarifai/workflows/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-clarifai/workflows/export.py,sha256=Oq3RVNKvv1iH46U6oIjXa-MXWJ4sTlXr_NSfwoxr3H4,2149
+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.0.dist-info/licenses/LICENSE,sha256=mUqF_d12-qE2n41g7C5_sq-BMLOcj6CNN-jevr15YHU,555
-clarifai-11.5.0.dist-info/METADATA,sha256=nHyy0pNlitK61Ym0VVAxz-Ev7UEtqpjyKrpbHwc2jmQ,22682
-clarifai-11.5.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-clarifai-11.5.0.dist-info/entry_points.txt,sha256=X9FZ4Z-i_r2Ud1RpZ9sNIFYuu_-9fogzCMCRUD9hyX0,51
-clarifai-11.5.0.dist-info/top_level.txt,sha256=wUMdCQGjkxaynZ6nZ9FAnvBUCgp5RJUVFSy2j-KYo0s,9
-clarifai-11.5.0.dist-info/RECORD,,
+clarifai-11.5.2.dist-info/licenses/LICENSE,sha256=mUqF_d12-qE2n41g7C5_sq-BMLOcj6CNN-jevr15YHU,555
+clarifai-11.5.2.dist-info/METADATA,sha256=RMLvJgPoDkyA4gjGfP0_LjJeN4encm6srVnGu7ibDBk,22736
+clarifai-11.5.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+clarifai-11.5.2.dist-info/entry_points.txt,sha256=X9FZ4Z-i_r2Ud1RpZ9sNIFYuu_-9fogzCMCRUD9hyX0,51
+clarifai-11.5.2.dist-info/top_level.txt,sha256=wUMdCQGjkxaynZ6nZ9FAnvBUCgp5RJUVFSy2j-KYo0s,9
+clarifai-11.5.2.dist-info/RECORD,,