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

clarifai/__init__.py

@@ -1 +1 @@
-__version__ = "11.4.10"
+__version__ = "11.5.1"

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/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/dummy_openai_model.py

@@ -13,9 +13,9 @@ class MockOpenAIClient:
         def create(self, **kwargs):
             """Mock create method for compatibility."""
             if kwargs.get("stream", False):
-                return MockCompletionStream(kwargs.get("messages", []))
+                return MockCompletionStream(**kwargs)
             else:
-                return MockCompletion(kwargs.get("messages", []))
+                return MockCompletion(**kwargs)
 
     def __init__(self):
         self.chat = self  # Make self.chat point to self for compatibility
@@ -25,6 +25,19 @@ class MockOpenAIClient:
 class MockCompletion:
     """Mock completion object that mimics the OpenAI completion response structure."""
 
+    class Usage:
+        def __init__(self, prompt_tokens, completion_tokens, total_tokens):
+            self.total_tokens = total_tokens
+            self.prompt_tokens = prompt_tokens
+            self.completion_tokens = completion_tokens
+
+        def to_dict(self):
+            return dict(
+                total_tokens=self.total_tokens,
+                prompt_tokens=self.prompt_tokens,
+                completion_tokens=self.completion_tokens,
+            )
+
     class Choice:
         class Message:
             def __init__(self, content):
@@ -36,17 +49,21 @@ class MockCompletion:
             self.finish_reason = "stop"
             self.index = 0
 
-    def __init__(self, messages):
+    def __init__(self, **kwargs):
         # Generate a simple response based on the last message
+        messages = kwargs.get("messages")
         last_message = messages[-1] if messages else {"content": ""}
         response_text = f"Echo: {last_message.get('content', '')}"
 
         self.choices = [self.Choice(response_text)]
-        self.usage = {
-            "prompt_tokens": len(str(messages)),
-            "completion_tokens": len(response_text),
-            "total_tokens": len(str(messages)) + len(response_text),
-        }
+        self.usage = self.Usage(
+            **{
+                "prompt_tokens": len(str(messages)),
+                "completion_tokens": len(response_text),
+                "total_tokens": len(str(messages)) + len(response_text),
+            }
+        )
+
         self.id = "dummy-completion-id"
         self.created = 1234567890
         self.model = "dummy-model"
@@ -65,9 +82,12 @@ class MockCompletion:
                 }
                 for choice in self.choices
             ],
-            "usage": self.usage,
+            "usage": self.usage.to_dict(),
         }
 
+    def model_dump(self):
+        return self.to_dict()
+
 
 class MockCompletionStream:
     """Mock completion stream that mimics the OpenAI streaming response structure."""
@@ -79,14 +99,27 @@ class MockCompletionStream:
                     self.content = content
                     self.role = "assistant" if content is None else None
 
+            class Usage:
+                def __init__(self, prompt_tokens, completion_tokens, total_tokens):
+                    self.total_tokens = total_tokens
+                    self.prompt_tokens = prompt_tokens
+                    self.completion_tokens = completion_tokens
+
+                def to_dict(self):
+                    return dict(
+                        total_tokens=self.total_tokens,
+                        prompt_tokens=self.prompt_tokens,
+                        completion_tokens=self.completion_tokens,
+                    )
+
             def __init__(self, content=None, include_usage=False):
                 self.delta = self.Delta(content)
                 self.finish_reason = None if content else "stop"
                 self.index = 0
                 self.usage = (
-                    {"prompt_tokens": 10, "completion_tokens": 5, "total_tokens": 15}
+                    self.Usage(**{"prompt_tokens": 10, "completion_tokens": 5, "total_tokens": 15})
                     if include_usage
-                    else None
+                    else self.Usage(None, None, None)
                 )
 
         def __init__(self, content=None, include_usage=False):
@@ -114,11 +147,16 @@ class MockCompletionStream:
                 ],
             }
             if self.usage:
-                result["usage"] = self.usage
+                result["usage"] = self.usage.to_dict()
             return result
 
-    def __init__(self, messages):
+        def model_dump(self):
+            return self.to_dict()
+
+    def __init__(self, **kwargs):
         # Generate a simple response based on the last message
+        messages = kwargs.get("messages")
+
         last_message = messages[-1] if messages else {"content": ""}
         self.response_text = f"Echo: {last_message.get('content', '')}"
         # Create chunks that ensure the full text is included in the first chunk
@@ -127,7 +165,7 @@ class MockCompletionStream:
             "",  # Final chunk is empty to indicate completion
         ]
         self.current_chunk = 0
-        self.include_usage = False
+        self.include_usage = kwargs.get("stream_options", {}).get("include_usage")
 
     def __iter__(self):
         return self
@@ -150,18 +188,14 @@ class DummyOpenAIModel(OpenAIModelClass):
     def _process_request(self, **kwargs) -> Dict[str, Any]:
         """Process a request for non-streaming responses."""
         completion_args = self._create_completion_args(kwargs)
-        return self.client.chat.completions.create(**completion_args).to_dict()
+        return self.client.chat.completions.create(**completion_args).model_dump()
 
     def _process_streaming_request(self, **kwargs) -> Iterator[Dict[str, Any]]:
         """Process a request for streaming responses."""
-        completion_args = self._create_completion_args(kwargs, stream=True)
-        completion_stream = self.client.chat.completions.create(**completion_args)
-        completion_stream.include_usage = kwargs.get('stream_options', {}).get(
-            'include_usage', False
-        )
+        completion_stream = self.client.chat.completions.create(**kwargs)
 
         for chunk in completion_stream:
-            yield chunk.to_dict()
+            yield chunk.model_dump()
 
     # Override the method directly for testing
     @OpenAIModelClass.method
@@ -169,14 +203,13 @@ class DummyOpenAIModel(OpenAIModelClass):
         """Direct implementation for testing purposes."""
         try:
             request_data = json.loads(req)
-            params = self._extract_request_params(request_data)
-
+            request_data = self._create_completion_args(request_data)
             # Validate messages
-            if not params.get("messages"):
+            if not request_data.get("messages"):
                 yield "Error: No messages provided"
                 return
 
-            for message in params["messages"]:
+            for message in request_data["messages"]:
                 if (
                     not isinstance(message, dict)
                     or "role" not in message
@@ -185,7 +218,7 @@ class DummyOpenAIModel(OpenAIModelClass):
                     yield "Error: Invalid message format"
                     return
 
-            for chunk in self._process_streaming_request(**params):
+            for chunk in self._process_streaming_request(**request_data):
                 yield json.dumps(chunk)
         except Exception as e:
             yield f"Error: {str(e)}"

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/models/openai_class.py

@@ -20,6 +20,15 @@ class OpenAIModelClass(ModelClass):
             model = "gpt-4"
     """
 
+    # API Endpoints
+    ENDPOINT_CHAT_COMPLETIONS = "/chat/completions"
+    ENDPOINT_IMAGES_GENERATE = "/images/generations"
+    ENDPOINT_EMBEDDINGS = "/embeddings"
+    ENDPOINT_RESPONSES = "/responses"
+
+    # Default endpoint
+    DEFAULT_ENDPOINT = ENDPOINT_CHAT_COMPLETIONS
+
     # These should be overridden in subclasses
     client = None
     model = None
@@ -35,141 +44,100 @@ class OpenAIModelClass(ModelClass):
                     "Subclasses must set the 'model' class attribute or ensure the client can list models"
                 ) from e
 
-    def _extract_request_params(self, request_data: Dict[str, Any]) -> Dict[str, Any]:
-        """Extract and validate common openai arguments parameters from the request data.
-
-        Args:
-            request_data: The parsed JSON request data
-
-        Returns:
-            Dict containing the extracted parameters
-        """
-        return {
-            "messages": request_data.get("messages", []),
-            "temperature": request_data.get("temperature", 1.0),
-            "max_tokens": request_data.get("max_tokens"),
-            "max_completion_tokens": request_data.get("max_completion_tokens"),
-            "n": request_data.get("n", 1),
-            "frequency_penalty": request_data.get("frequency_penalty"),
-            "presence_penalty": request_data.get("presence_penalty"),
-            "top_p": request_data.get("top_p", 1.0),
-            "reasoning_effort": request_data.get("reasoning_effort"),
-            "response_format": request_data.get("response_format"),
-            "stop": request_data.get("stop"),
-            "tools": request_data.get("tools"),
-            "tool_choice": request_data.get("tool_choice"),
-            "tool_resources": request_data.get("tool_resources"),
-            "modalities": request_data.get("modalities"),
-            "stream_options": request_data.get("stream_options", {"include_usage": True}),
-        }
-
-    def _create_completion_args(
-        self, params: Dict[str, Any], stream: bool = False
-    ) -> Dict[str, Any]:
+    def _create_completion_args(self, params: Dict[str, Any]) -> Dict[str, Any]:
         """Create the completion arguments dictionary from parameters.
 
         Args:
             params: Dictionary of parameters extracted from request
-            stream: Whether this is a streaming request
 
         Returns:
             Dict containing the completion arguments
         """
-        completion_args = {
-            "model": self.model,
-            "messages": params["messages"],
-            "temperature": params["temperature"],
-        }
-
+        completion_args = {**params}
+        completion_args.update({"model": self.model})
+        stream = completion_args.pop("stream", False)
         if stream:
-            completion_args["stream"] = True
-            if params.get("stream_options"):
-                completion_args["stream_options"] = params["stream_options"]
-
-        # Add optional parameters if they exist
-        optional_params = [
-            "max_tokens",
-            "max_completion_tokens",
-            "n",
-            "frequency_penalty",
-            "presence_penalty",
-            "top_p",
-            "reasoning_effort",
-            "response_format",
-            "stop",
-            "tools",
-            "tool_choice",
-            "tool_resources",
-            "modalities",
-        ]
-
-        for param in optional_params:
-            if params.get(param) is not None:
-                completion_args[param] = params[param]
+            # Force to use usage
+            stream_options = params.pop("stream_options", {})
+            stream_options.update({"include_usage": True})
+            completion_args["stream_options"] = stream_options
+        completion_args["stream"] = stream
 
         return completion_args
 
-    def _format_error_response(self, error: Exception) -> str:
-        """Format an error response in OpenAI-compatible format.
+    def _set_usage(self, resp):
+        if resp.usage and resp.usage.prompt_tokens and resp.usage.completion_tokens:
+            self.set_output_context(
+                prompt_tokens=resp.usage.prompt_tokens,
+                completion_tokens=resp.usage.completion_tokens,
+            )
+
+    def _handle_chat_completions(self, request_data: Dict[str, Any]):
+        """Handle chat completion requests."""
+        completion_args = self._create_completion_args(request_data)
+        completion = self.client.chat.completions.create(**completion_args)
+        self._set_usage(completion)
+        return completion
+
+    def _handle_images_generate(self, request_data: Dict[str, Any]):
+        """Handle image generation requests."""
+        image_args = {**request_data}
+        image_args.update({"model": self.model})
+        response = self.client.images.generate(**image_args)
+        return response
+
+    def _handle_embeddings(self, request_data: Dict[str, Any]):
+        """Handle embedding requests."""
+        embedding_args = {**request_data}
+        embedding_args.update({"model": self.model})
+        response = self.client.embeddings.create(**embedding_args)
+        return response
+
+    def _handle_responses(self, request_data: Dict[str, Any]):
+        """Handle response requests."""
+        response_args = {**request_data}
+        response_args.update({"model": self.model})
+        response = self.client.responses.create(**response_args)
+        return response
+
+    def _route_request(self, endpoint: str, request_data: Dict[str, Any]):
+        """Route the request to appropriate handler based on endpoint."""
+        handlers = {
+            self.ENDPOINT_CHAT_COMPLETIONS: self._handle_chat_completions,
+            self.ENDPOINT_IMAGES_GENERATE: self._handle_images_generate,
+            self.ENDPOINT_EMBEDDINGS: self._handle_embeddings,
+            self.ENDPOINT_RESPONSES: self._handle_responses,
+        }
 
-        Args:
-            error: The exception that occurred
+        handler = handlers.get(endpoint)
+        if not handler:
+            raise ValueError(f"Unsupported endpoint: {endpoint}")
 
-        Returns:
-            JSON string containing the error response
-        """
-        error_response = {
-            "error": {
-                "message": str(error),
-                "type": "InvalidRequestError",
-                "code": "invalid_request_error",
-            }
-        }
-        return json.dumps(error_response)
+        return handler(request_data)
 
     @ModelClass.method
     def openai_transport(self, msg: str) -> str:
-        """The single model method to get the OpenAI-compatible request and send it to the OpenAI server
-        then return its response.
+        """Process an OpenAI-compatible request and send it to the appropriate OpenAI endpoint.
 
         Args:
-            msg: JSON string containing the request parameters
+            msg: JSON string containing the request parameters including 'openai_endpoint'
 
         Returns:
             JSON string containing the response or error
         """
         try:
             request_data = json.loads(msg)
-            params = self._extract_request_params(request_data)
-            stream = request_data.get("stream", False)
-
-            if stream:
-                chunks = self._process_streaming_request(**params)
-                response_list = []
-                for chunk in chunks:
-                    response_list.append(chunk)
-                return json.dumps(response_list)
-            else:
-                completion = self._process_request(**params)
-                if completion.get('usage'):
-                    if completion['usage'].get('prompt_tokens') and completion['usage'].get(
-                        'completion_tokens'
-                    ):
-                        self.set_output_context(
-                            prompt_tokens=completion['usage']['prompt_tokens'],
-                            completion_tokens=completion['usage']['completion_tokens'],
-                        )
-
-                return json.dumps(completion)
-
+            endpoint = request_data.pop("openai_endpoint", self.DEFAULT_ENDPOINT)
+            response = self._route_request(endpoint, request_data)
+            return json.dumps(response.model_dump())
         except Exception as e:
-            return self._format_error_response(e)
+            return f"Error: {e}"
 
     @ModelClass.method
     def openai_stream_transport(self, msg: str) -> Iterator[str]:
         """Process an OpenAI-compatible request and return a streaming response iterator.
         This method is used when stream=True and returns an iterator of strings directly,
-        without converting to a list or JSON serializing.
+        without converting to a list or JSON serializing. Supports chat completions and responses endpoints.
 
         Args:
             msg: The request as a JSON string.
@@ -179,43 +147,21 @@ class OpenAIModelClass(ModelClass):
         """
         try:
             request_data = json.loads(msg)
-            params = self._extract_request_params(request_data)
-            for chunk in self._process_streaming_request(**params):
-                if chunk.get('usage'):
-                    if chunk['usage'].get('prompt_tokens') and chunk['usage'].get(
-                        'completion_tokens'
-                    ):
-                        self.set_output_context(
-                            prompt_tokens=chunk['usage']['prompt_tokens'],
-                            completion_tokens=chunk['usage']['completion_tokens'],
-                        )
-                yield json.dumps(chunk)
-        except Exception as e:
-            yield f"Error: {str(e)}"
-
-    def _process_request(self, **kwargs) -> Any:
-        """Process a standard (non-streaming) request using the OpenAI client.
-
-        Args:
-            **kwargs: Request parameters
-
-        Returns:
-            The completion response from the OpenAI client
-        """
-        completion_args = self._create_completion_args(kwargs)
-        return self.client.chat.completions.create(**completion_args).to_dict()
-
-    def _process_streaming_request(self, **kwargs) -> Iterator[str]:
-        """Process a streaming request using the OpenAI client.
-
-        Args:
-            **kwargs: Request parameters
-
-        Returns:
-            Iterator yielding response chunks
-        """
-        completion_args = self._create_completion_args(kwargs, stream=True)
-        completion_stream = self.client.chat.completions.create(**completion_args)
+            endpoint = request_data.pop("openai_endpoint", self.DEFAULT_ENDPOINT)
+            if endpoint not in [self.ENDPOINT_CHAT_COMPLETIONS, self.ENDPOINT_RESPONSES]:
+                raise ValueError("Streaming is only supported for chat completions and responses.")
+
+            if endpoint == self.ENDPOINT_RESPONSES:
+                # Handle responses endpoint
+                stream_response = self._route_request(endpoint, request_data)
+                for chunk in stream_response:
+                    yield json.dumps(chunk.model_dump())
+            else:
+                completion_args = self._create_completion_args(request_data)
+                stream_completion = self.client.chat.completions.create(**completion_args)
+                for chunk in stream_completion:
+                    self._set_usage(chunk)
+                    yield json.dumps(chunk.model_dump())
 
-        for chunk in completion_stream:
-            yield chunk.to_dict()
+        except Exception as e:
+            yield f"Error: {e}"

clarifai/runners/models/visual_classifier_class.py

@@ -52,7 +52,7 @@ class VisualClassifierClass(ModelClass):
 
     @staticmethod
     def process_concepts(
-        logits: torch.Tensor, threshold: float, model_labels: Dict[int, str]
+        logits: torch.Tensor, model_labels: Dict[int, str]
     ) -> List[List[Concept]]:
         """Convert model logits into a structured format of concepts.
 

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?",
@@ -111,7 +111,7 @@ model = Model.from_current_context()"""
     else:
         model_ui_url = url_helper.clarifai_url(user_id, app_id, "models", model_id)
         model_section = f"""
-model = Model({model_ui_url},
+model = Model("{model_ui_url}",
                deployment_id = {deployment_id}, # Only needed for dedicated deployed models
                {base_url_str}
  )
@@ -133,6 +133,8 @@ model = Model({model_ui_url},
                 continue
             if default_value is None and required:
                 default_value = _set_default_value(param_type)
+            if param_type == "str" and default_value is not None:
+                default_value = json.dumps(default_value)
             client_script_str += f"{param_name}={default_value}, "
         client_script_str = client_script_str.rstrip(", ") + ")"
         if method_signature.method_type == resources_pb2.RunnerMethodType.UNARY_UNARY:

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/runners/utils/data_utils.py

@@ -377,8 +377,14 @@ class Param(MessageData):
 
             if proto is None:
                 proto = ParamProto()
-            proto.default = json.dumps(default)
+
+            if isinstance(default, str):
+                proto.default = default
+            else:
+                proto.default = json.dumps(default)
+
             return proto
+
         except Exception:
             if default is not None:
                 proto.default = str(default)

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.4.10.dist-info → clarifai-11.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clarifai
-Version: 11.4.10
+Version: 11.5.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.3.4
-Requires-Dist: clarifai-protocol>=0.0.23
+Requires-Dist: clarifai-grpc>=11.5.5
+Requires-Dist: clarifai-protocol>=0.0.24
 Requires-Dist: numpy>=1.22.0
 Requires-Dist: tqdm>=4.65.0
 Requires-Dist: PyYAML>=6.0.1
@@ -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.4.10.dist-info → clarifai-11.5.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-clarifai/__init__.py,sha256=R3Gdk_es4xqWH9Q0o6LQE5mk81Nh9rli5JkK7PNOfDs,24
+clarifai/__init__.py,sha256=A0jDR9AvI6Hw5Et83NIgHO8iH3ugm5KfZXEJRyobuHc,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
@@ -12,7 +12,7 @@ clarifai/cli/model.py,sha256=9sJ5p4TJc41vOeeFoMC3e8cciscSU7TmvAgW0wfO54U,30191
 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
@@ -64,24 +64,24 @@ 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=5oa7r8j1GpymenpmMfaAV9Vt6VObKvrT9tDXgFmP4qY,7208
-clarifai/runners/models/mcp_class.py,sha256=7uwCMade0LMMBq7vczhPf4Kxdmh8Rj0R7Pg3pPxYdjQ,6386
-clarifai/runners/models/model_builder.py,sha256=PiqPyTGPSKsYvOQNpBzs4e1_wuEbtE-P3yEkLE4Py10,49231
+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=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
 clarifai/runners/models/model_servicer.py,sha256=rRd_fNEXwqiBSzTUtPI2r07EBdcCPd8tcSPHeqTe0_I,3445
-clarifai/runners/models/openai_class.py,sha256=3u6K7vTdYybxdTT3t3pYh9wvQyWhkL595t7hR5IkljU,8159
-clarifai/runners/models/visual_classifier_class.py,sha256=f9ZP8KFamMUdMpUG3AlL9nVCdcggy_E5n9RJY3ixR1U,2739
+clarifai/runners/models/openai_class.py,sha256=aXlk5W6LWkh-A4eZYi74DeLW0i_86_9DYYGxpJHXI0w,6688
+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=fiuwsY-uxmMzQXBv1V8Gpw0n6s_xzrigAk4J5htOAao,12646
-clarifai/runners/utils/const.py,sha256=Q4Ps6gIEJCyTdQCfmT6PaS61WHmhT25XigV1NugWz-E,1544
-clarifai/runners/utils/data_utils.py,sha256=4M4n-cGprBEBV5UkgOWaUlVfZ3WBTmegdffGQ3SfYCU,20750
+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
 clarifai/runners/utils/openai_convertor.py,sha256=ZlIrvvfHttD_DavLvmKZdL8gNq_TQvQtZVnYamwdWz4,8248
@@ -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.4.10.dist-info/licenses/LICENSE,sha256=mUqF_d12-qE2n41g7C5_sq-BMLOcj6CNN-jevr15YHU,555
-clarifai-11.4.10.dist-info/METADATA,sha256=fsyNNmQS46MJ-hkKLiw2yK23x516-GOjPrm0CNOcNrI,22683
-clarifai-11.4.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-clarifai-11.4.10.dist-info/entry_points.txt,sha256=X9FZ4Z-i_r2Ud1RpZ9sNIFYuu_-9fogzCMCRUD9hyX0,51
-clarifai-11.4.10.dist-info/top_level.txt,sha256=wUMdCQGjkxaynZ6nZ9FAnvBUCgp5RJUVFSy2j-KYo0s,9
-clarifai-11.4.10.dist-info/RECORD,,
+clarifai-11.5.1.dist-info/licenses/LICENSE,sha256=mUqF_d12-qE2n41g7C5_sq-BMLOcj6CNN-jevr15YHU,555
+clarifai-11.5.1.dist-info/METADATA,sha256=-TWdB_qQgO1GbJrjYq6dpEn8wJVgftsyK_E664VBEgU,22736
+clarifai-11.5.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+clarifai-11.5.1.dist-info/entry_points.txt,sha256=X9FZ4Z-i_r2Ud1RpZ9sNIFYuu_-9fogzCMCRUD9hyX0,51
+clarifai-11.5.1.dist-info/top_level.txt,sha256=wUMdCQGjkxaynZ6nZ9FAnvBUCgp5RJUVFSy2j-KYo0s,9
+clarifai-11.5.1.dist-info/RECORD,,