clarifai 11.6.8__py3-none-any.whl → 11.7.0__py3-none-any.whl

clarifai/__init__.py

@@ -1 +1 @@
-__version__ = "11.6.8"
+__version__ = "11.7.0"

clarifai/cli/model.py

@@ -298,7 +298,7 @@ def init(
 @click.option(
     '--skip_dockerfile',
     is_flag=True,
-    help='Flag to skip generating a dockerfile so that you can manually edit an already created dockerfile.',
+    help='Flag to skip generating a dockerfile so that you can manually edit an already created dockerfile. If not provided, intelligently handle existing Dockerfiles with user confirmation.',
 )
 @click.pass_context
 def upload(ctx, model_path, stage, skip_dockerfile):
@@ -410,7 +410,7 @@ def signatures(model_path, out_path):
 @click.option(
     '--skip_dockerfile',
     is_flag=True,
-    help='Flag to skip generating a dockerfile so that you can manually edit an already created dockerfile. Apply for `--mode conatainer`.',
+    help='Flag to skip generating a dockerfile so that you can manually edit an already created dockerfile. If not provided, intelligently handle existing Dockerfiles with user confirmation.',
 )
 def test_locally(model_path, keep_env=False, keep_image=False, mode='env', skip_dockerfile=False):
     """Test model locally.
@@ -477,7 +477,7 @@ def test_locally(model_path, keep_env=False, keep_image=False, mode='env', skip_
 @click.option(
     '--skip_dockerfile',
     is_flag=True,
-    help='Flag to skip generating a dockerfile so that you can manually edit an already created dockerfile. Apply for `--mode conatainer`.',
+    help='Flag to skip generating a dockerfile so that you can manually edit an already created dockerfile. If not provided, intelligently handle existing Dockerfiles with user confirmation.',
 )
 def run_locally(model_path, port, mode, keep_env, keep_image, skip_dockerfile=False):
     """Run the model locally and start a gRPC server to serve the model.
@@ -520,7 +520,7 @@ def run_locally(model_path, port, mode, keep_env, keep_image, skip_dockerfile=Fa
 @click.option(
     "--pool_size",
     type=int,
-    default=1,  # default to 1 thread for local runner to avoid rapid depletion of compute time.
+    default=32,
     show_default=True,
     help="The number of threads to use. On community plan, the compute time allocation is drained at a rate proportional to the number of threads.",
 )  # pylint: disable=range-builtin-not-iterating
@@ -571,6 +571,8 @@ def local_runner(ctx, model_path, pool_size, verbose):
     from clarifai.runners.models.model_builder import ModelBuilder
     from clarifai.runners.server import serve
 
+    builder = ModelBuilder(model_path, download_validation_only=True)
+
     validate_context(ctx)
     builder = ModelBuilder(model_path, download_validation_only=True)
     logger.info("> Checking local runner requirements...")
@@ -726,16 +728,20 @@ def local_runner(ctx, model_path, pool_size, verbose):
     # Now we need to create a version for the model if no version exists. Only need one version that
     # mentions it's a local runner.
     model_versions = [v for v in model.list_versions()]
+    method_signatures = builder.get_method_signatures(mocking=False)
     if len(model_versions) == 0:
         logger.warning("No model versions found. Creating a new version for local runner.")
-        # add the signatures for local runner on how to call it.
-        signatures = builder.get_method_signatures(mocking=True)
         version = model.create_version(
-            pretrained_model_config={"local_dev": True}, method_signatures=signatures
+            pretrained_model_config={"local_dev": True}, method_signatures=method_signatures
         ).model_version
         ctx.obj.current.CLARIFAI_MODEL_VERSION_ID = version.id
         ctx.obj.to_yaml()
     else:
+        model.patch_version(
+            version_id=model_versions[0].model_version.id,
+            pretrained_model_config={"local_dev": True},
+            method_signatures=method_signatures,
+        )
         version = model_versions[0].model_version
         ctx.obj.current.CLARIFAI_MODEL_VERSION_ID = version.id
         ctx.obj.to_yaml()  # save to yaml file.
@@ -864,7 +870,6 @@ def local_runner(ctx, model_path, pool_size, verbose):
         ModelBuilder._backup_config(config_file)
         ModelBuilder._save_config(config_file, config)
 
-    builder = ModelBuilder(model_path, download_validation_only=True)
     if not check_requirements_installed(model_path):
         logger.error(f"Requirements not installed for model at {model_path}.")
         raise click.Abort()

clarifai/cli/templates/model_templates.py

@@ -204,8 +204,9 @@ inference_compute_info:
 # TODO: please fill in (optional) - add checkpoints section if needed
 # checkpoints:
 #   type: "huggingface"  # supported type
-#   repo_id: "your-model-repo"  # for huggingface
-#   when: "build"  # or "runtime", "upload"
+#   repo_id: "your-model-repo"  # for huggingface like openai/gpt-oss-20b
+#   # hf_token: "your-huggingface-token"  # if private repo
+#   when: "runtime"  # or "build", "upload"
 '''
 
 

clarifai/client/auth/helper.py

@@ -1,6 +1,6 @@
 import os
 import urllib.request
-from typing import Any, Dict
+from typing import Any, Dict, Tuple
 
 import grpc
 from clarifai_grpc.channel.clarifai_channel import ClarifaiChannel
@@ -293,7 +293,7 @@ class ClarifaiAuthHelper:
         stub, channel = self.get_stub_and_channel()
         return stub
 
-    def get_stub_and_channel(self) -> tuple[service_pb2_grpc.V2Stub, grpc.Channel]:
+    def get_stub_and_channel(self) -> Tuple[service_pb2_grpc.V2Stub, grpc.Channel]:
         """Get the API gRPC stub and channel based on the API endpoint base.
 
         Returns:

clarifai/client/model.py

@@ -2101,3 +2101,33 @@ class Model(Lister, BaseClient):
             model_id=self.id,
             model_version=dict(id=response.model.model_version.id),
         )
+
+    def patch_version(self, version_id: str, **kwargs) -> 'Model':
+        """Patch the model version with the given version ID.
+        Args:
+            version_id (str): The version ID to patch.
+            **kwargs: Additional keyword arguments to update the model version.
+        Example:
+            >>> from clarifai.client.model import Model
+            >>> model = Model(model_id='model_id', user_id='user_id', app_id='app_id')
+            >>> model.patch_version(version_id='version_id', method_signatures=signatures)
+        """
+        request = service_pb2.PatchModelVersionsRequest(
+            user_app_id=self.user_app_id,
+            model_id=self.id,
+            action='merge',
+            model_versions=[
+                resources_pb2.ModelVersion(
+                    id=version_id,
+                    **kwargs,
+                )
+            ],
+        )
+        response = self._grpc_request(self.STUB.PatchModelVersions, request)
+        if response.status.code != status_code_pb2.SUCCESS:
+            raise Exception(response.status)
+        return Model.from_auth_helper(
+            auth=self.auth_helper,
+            model_id=self.id,
+            model_version=dict(id=version_id),
+        )

clarifai/runners/models/dummy_openai_model.py

@@ -88,6 +88,10 @@ class MockCompletion:
     def model_dump(self):
         return self.to_dict()
 
+    def model_dump_json(self):
+        """Return the completion as a JSON string."""
+        return json.dumps(self.to_dict())
+
 
 class MockCompletionStream:
     """Mock completion stream that mimics the OpenAI streaming response structure."""
@@ -153,6 +157,10 @@ class MockCompletionStream:
         def model_dump(self):
             return self.to_dict()
 
+        def model_dump_json(self):
+            """Return the chunk as a JSON string."""
+            return json.dumps(self.to_dict())
+
     def __init__(self, **kwargs):
         # Generate a simple response based on the last message
         messages = kwargs.get("messages")

clarifai/runners/models/model_builder.py

@@ -21,6 +21,7 @@ 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 import code_script
 from clarifai.runners.utils.const import (
     AMD_PYTHON_BASE_IMAGE,
     AMD_TORCH_BASE_IMAGE,
@@ -101,6 +102,7 @@ class ModelBuilder:
         self.folder = self._validate_folder(folder)
         self.config = self._load_config(os.path.join(self.folder, 'config.yaml'))
         self._validate_config()
+        self._validate_stream_options()
         self.model_proto = self._get_model_proto()
         self.model_id = self.model_proto.id
         self.model_version_id = None
@@ -440,6 +442,89 @@ class ModelBuilder:
             num_threads = int(os.environ.get("CLARIFAI_NUM_THREADS", 16))
             self.config["num_threads"] = num_threads
 
+    def _validate_stream_options(self):
+        """
+        Validate OpenAI streaming configuration for Clarifai models.
+        """
+        if not self._is_clarifai_internal():
+            return  # Skip validation for non-clarifai models
+
+        # Parse all Python files once
+        all_python_content = self._get_all_python_content()
+
+        if self._uses_openai_streaming(all_python_content):
+            logger.info(
+                "Detected OpenAI chat completions for Clarifai model streaming - validating stream_options..."
+            )
+
+            if not self.has_proper_usage_tracking(all_python_content):
+                logger.error(
+                    "Missing configuration to track usage for OpenAI chat completion calls. "
+                    "Go to your model scripts and make sure to set both: "
+                    "1) stream_options={'include_usage': True}"
+                    "2) set_output_context"
+                )
+
+    def _is_clarifai_internal(self):
+        """
+        Check if the current user is a Clarifai internal user based on email domain.
+
+        Returns:
+            bool: True if user is a Clarifai internal user, False otherwise
+        """
+        try:
+            # Get user info from Clarifai API
+            user_client = User(
+                pat=self.client.pat, user_id=self.config.get('model').get('user_id')
+            )
+            user_response = user_client.get_user_info()
+
+            if user_response.status.code != status_code_pb2.SUCCESS:
+                logger.debug("Could not retrieve user info for Clarifai internal user validation")
+                return False
+
+            user = user_response.user
+
+            # Check primary email domain
+            if hasattr(user, 'primary_email') and user.primary_email:
+                return user.primary_email.endswith('@clarifai.com')
+
+            return False
+
+        except Exception as e:
+            logger.debug(f"Employee validation failed: {e}")
+            return False
+
+    def _get_all_python_content(self):
+        """
+        Parse and concatenate all Python files in the model's 1/ subfolder.
+        """
+        model_folder = os.path.join(self.folder, '1')
+        if not os.path.exists(model_folder):
+            return ""
+
+        all_content = []
+        for root, _, files in os.walk(model_folder):
+            for file in files:
+                if file.endswith('.py'):
+                    file_path = os.path.join(root, file)
+                    try:
+                        with open(file_path, 'r', encoding='utf-8') as f:
+                            all_content.append(f.read())
+                    except Exception:
+                        continue
+        return "\n".join(all_content)
+
+    def _uses_openai_streaming(self, python_content):
+        return 'chat.completions.create' in python_content and 'generate(' in python_content
+
+    def has_proper_usage_tracking(self, python_content):
+        include_usage_patterns = ["'include_usage': True", '"include_usage": True']
+        has_include_usage = any(pattern in python_content for pattern in include_usage_patterns)
+        has_set_output_context = 'set_output_context' in python_content
+
+        return has_include_usage and has_set_output_context
+
     @staticmethod
     def _get_tar_file_content_size(tar_file_path):
         """
@@ -736,7 +821,26 @@ class ModelBuilder:
         else:
             logger.info("Setup: Python code linted successfully, no errors found.")
 
-    def create_dockerfile(self):
+    def _normalize_dockerfile_content(self, content):
+        """
+        Normalize Dockerfile content for comparison by standardizing whitespace and indentation.
+        This handles differences in spacing, indentation, and line endings.
+        """
+        lines = []
+        for line in content.splitlines():
+            # Strip leading/trailing whitespace from each line
+            normalized_line = line.strip()
+            # Skip empty lines for comparison
+            if normalized_line:
+                lines.append(normalized_line)
+        # Join with consistent line endings
+        return '\n'.join(lines)
+
+    def _generate_dockerfile_content(self):
+        """
+        Generate the Dockerfile content based on the model configuration.
+        This is a helper method that returns the content without writing to file.
+        """
         dockerfile_template = os.path.join(
             os.path.dirname(os.path.dirname(__file__)),
             'dockerfile_template',
@@ -885,9 +989,51 @@ class ModelBuilder:
             CLARIFAI_VERSION=clarifai_version,  # for clarifai
         )
 
-        # Write Dockerfile
-        with open(os.path.join(self.folder, 'Dockerfile'), 'w') as dockerfile:
-            dockerfile.write(dockerfile_content)
+        return dockerfile_content
+
+    def create_dockerfile(self, generate_dockerfile=False):
+        """
+        Create a Dockerfile for the model based on its configuration.
+        """
+        generated_content = self._generate_dockerfile_content()
+
+        if generate_dockerfile:
+            should_create_dockerfile = True
+        else:
+            # Always handle Dockerfile creation with user interaction when content differs
+            dockerfile_path = os.path.join(self.folder, 'Dockerfile')
+            should_create_dockerfile = True
+
+            if os.path.exists(dockerfile_path):
+                # Read existing Dockerfile content
+                with open(dockerfile_path, 'r') as existing_dockerfile:
+                    existing_content = existing_dockerfile.read()
+
+                # Compare content (normalize for robust comparison that handles indentation differences)
+                if self._normalize_dockerfile_content(
+                    existing_content
+                ) == self._normalize_dockerfile_content(generated_content):
+                    logger.info(
+                        "Dockerfile already exists with identical content, skipping creation."
+                    )
+                    should_create_dockerfile = False
+                else:
+                    logger.info("Dockerfile already exists with different content.")
+                    response = input(
+                        "A different Dockerfile already exists. Do you want to overwrite it with the generated one? "
+                        "Type 'y' to overwrite, 'n' to keep your custom Dockerfile: "
+                    )
+                    if response.lower() != 'y':
+                        logger.info("Keeping existing custom Dockerfile.")
+                        should_create_dockerfile = False
+                    else:
+                        logger.info("Overwriting existing Dockerfile with generated content.")
+
+        if should_create_dockerfile:
+            # Write Dockerfile
+            dockerfile_path = os.path.join(self.folder, 'Dockerfile')
+            with open(dockerfile_path, 'w') as dockerfile:
+                dockerfile.write(generated_content)
 
     @property
     def checkpoint_path(self):
@@ -1119,7 +1265,6 @@ class ModelBuilder:
             is_uploaded = self.monitor_model_build()
             if is_uploaded:
                 # python code to run the model.
-                from clarifai.runners.utils import code_script
 
                 method_signatures = self.get_method_signatures()
                 snippet = code_script.generate_client_script(
@@ -1197,7 +1342,6 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
             per_page=50,
         )
         response = self.client.STUB.ListLogEntries(logs_request)
-
         return response
 
     def monitor_model_build(self):
@@ -1250,14 +1394,16 @@ def upload_model(folder, stage, skip_dockerfile, pat=None, base_url=None):
 
     :param folder: The folder containing the model files.
     :param stage: The stage we are calling download checkpoints from. Typically this would "upload" and will download checkpoints if config.yaml checkpoints section has when set to "upload". Other options include "runtime" to be used in load_model or "upload" to be used during model upload. Set this stage to whatever you have in config.yaml to force downloading now.
-    :param skip_dockerfile: If True, will not create a Dockerfile.
+    :param skip_dockerfile: If True, will skip Dockerfile generation entirely. If False or not provided, intelligently handle existing Dockerfiles with user confirmation.
     :param pat: Personal access token for authentication. If None, will use environment variables.
     :param base_url: Base URL for the API. If None, will use environment variables.
     """
     builder = ModelBuilder(folder, app_not_found_action="prompt", pat=pat, base_url=base_url)
     builder.download_checkpoints(stage=stage)
+
     if not skip_dockerfile:
         builder.create_dockerfile()
+
     exists = builder.check_model_exists()
     if exists:
         logger.info(
@@ -1272,13 +1418,14 @@ def upload_model(folder, stage, skip_dockerfile, pat=None, base_url=None):
     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
+    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':
+            logger.info("Model uploaded successfully. Skipping deployment setup.")
+            return
 
-    # Setup deployment for the uploaded model
-    setup_deployment_for_model(builder)
+        # Setup deployment for the uploaded model
+        setup_deployment_for_model(builder)
 
 
 def setup_deployment_for_model(builder):
@@ -1459,7 +1606,7 @@ def setup_deployment_for_model(builder):
     # 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}"
+    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
@@ -1473,4 +1620,3 @@ def setup_deployment_for_model(builder):
             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

@@ -1,9 +1,12 @@
 """Base class for creating OpenAI-compatible API server."""
 
-import json
 from typing import Any, Dict, Iterator
 
+from clarifai_grpc.grpc.api.status import status_code_pb2
+from pydantic_core import from_json, to_json
+
 from clarifai.runners.models.model_class import ModelClass
+from clarifai.utils.logging import logger
 
 
 class OpenAIModelClass(ModelClass):
@@ -116,6 +119,33 @@ class OpenAIModelClass(ModelClass):
 
         return handler(request_data)
 
+    def _update_old_fields(self, request_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Update old fields in the request data to match current API expectations.
+
+        This is needed because API callers may have an old openAI client sending old fields
+        compared to the client within the model.
+
+        Note: this updates the request data in place and returns it.
+        """
+        if 'max_tokens' in request_data:
+            request_data['max_completion_tokens'] = request_data.pop('max_tokens')
+        if 'top_p' in request_data:
+            request_data['top_p'] = float(request_data['top_p'])
+        # Note(zeiler): temporary fix for our playground sending additional fields.
+        # FIXME: remove this once the playground is updated.
+        for m in request_data['messages']:
+            m.pop('id', None)
+            m.pop('file', None)
+            m.pop('panelId', None)
+
+        # Handle the "Currently only named tools are supported." error we see from trt-llm
+        if 'tools' in request_data and request_data['tools'] is None:
+            request_data.pop('tools', None)
+        if 'tool_choice' in request_data and request_data['tool_choice'] is None:
+            request_data.pop('tool_choice', None)
+
+        return request_data
+
     @ModelClass.method
     def openai_transport(self, msg: str) -> str:
         """Process an OpenAI-compatible request and send it to the appropriate OpenAI endpoint.
@@ -127,12 +157,19 @@ class OpenAIModelClass(ModelClass):
             JSON string containing the response or error
         """
         try:
-            request_data = json.loads(msg)
+            request_data = from_json(msg)
+            request_data = self._update_old_fields(request_data)
             endpoint = request_data.pop("openai_endpoint", self.DEFAULT_ENDPOINT)
             response = self._route_request(endpoint, request_data)
-            return json.dumps(response.model_dump())
+            return response.model_dump_json()
         except Exception as e:
-            return f"Error: {e}"
+            logger.exception(e)
+            error_obj = {
+                "code": status_code_pb2.MODEL_PREDICTION_FAILED,
+                "description": "Model prediction failed",
+                "details": str(e),
+            }
+            return to_json(error_obj)
 
     @ModelClass.method
     def openai_stream_transport(self, msg: str) -> Iterator[str]:
@@ -147,7 +184,8 @@ class OpenAIModelClass(ModelClass):
             Iterator[str]: An iterator yielding text chunks from the streaming response.
         """
         try:
-            request_data = json.loads(msg)
+            request_data = from_json(msg)
+            request_data = self._update_old_fields(request_data)
             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.")
@@ -156,13 +194,19 @@ class OpenAIModelClass(ModelClass):
                 # Handle responses endpoint
                 stream_response = self._route_request(endpoint, request_data)
                 for chunk in stream_response:
-                    yield json.dumps(chunk.model_dump())
+                    yield chunk.model_dump_json()
             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())
+                    yield chunk.model_dump_json()
 
         except Exception as e:
-            yield f"Error: {e}"
+            logger.exception(e)
+            error_obj = {
+                "code": status_code_pb2.MODEL_PREDICTION_FAILED,
+                "description": "Model prediction failed",
+                "details": str(e),
+            }
+            yield to_json(error_obj)

{clarifai-11.6.8.dist-info → clarifai-11.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clarifai
-Version: 11.6.8
+Version: 11.7.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.6.6
-Requires-Dist: clarifai-protocol>=0.0.25
+Requires-Dist: clarifai-grpc>=11.7.5
+Requires-Dist: clarifai-protocol>=0.0.27
 Requires-Dist: numpy>=1.22.0
 Requires-Dist: tqdm>=4.65.0
 Requires-Dist: PyYAML>=6.0.1
@@ -32,7 +32,10 @@ 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
 Requires-Dist: psutil==7.0.0
+Requires-Dist: pydantic_core==2.33.2
+Requires-Dist: packaging==25.0
 Provides-Extra: all
 Requires-Dist: pycocotools>=2.0.7; extra == "all"
 Dynamic: author
@@ -72,7 +75,7 @@ Clarifai Python SDK
 
 This is the official Python client for interacting with our powerful [API](https://docs.clarifai.com). The Clarifai Python SDK offers a comprehensive set of tools to integrate Clarifai's AI platform to leverage computer vision capabilities like classification , detection ,segementation and natural language capabilities like classification , summarisation , generation , Q&A ,etc into your applications. With just a few lines of code, you can leverage cutting-edge artificial intelligence to unlock valuable insights from visual and textual content.
 
-[Website](https://www.clarifai.com/) | [Schedule Demo](https://www.clarifai.com/company/schedule-demo) | [Signup for a Free Account](https://clarifai.com/signup) | [API Docs](https://docs.clarifai.com/) | [Clarifai Community](https://clarifai.com/explore) | [Python SDK Docs](https://docs.clarifai.com/python-sdk/api-reference) | [Examples](https://github.com/Clarifai/examples) | [Colab Notebooks](https://github.com/Clarifai/colab-notebooks) | [Discord](https://discord.gg/XAPE3Vtg)
+[Website](https://www.clarifai.com/) | [Schedule Demo](https://www.clarifai.com/company/schedule-demo) | [Signup for a Free Account](https://clarifai.com/signup) | [API Docs](https://docs.clarifai.com/) | [Clarifai Community](https://clarifai.com/explore) | [Python SDK Docs](https://docs.clarifai.com/resources/api-references/python) | [Examples](https://github.com/Clarifai/examples) | [Colab Notebooks](https://github.com/Clarifai/colab-notebooks) | [Discord](https://discord.gg/XAPE3Vtg)
 
 Give the repo a star ⭐
 ---
@@ -130,10 +133,25 @@ git clone https://github.com/Clarifai/clarifai-python.git
 cd clarifai-python
 python3 -m venv .venv
 source .venv/bin/activate
-pip install -r requirements.txt
-python setup.py install
+pip install -e .
 ```
 
+#### Linting
+
+For developers, use the precommit hook `.pre-commit-config.yaml` to automate linting.
+
+```bash
+pip install -r requirements-dev.txt
+pre-commit install
+```
+
+Now every time you run `git commit` your code will be automatically linted and won't commit if it fails.
+
+You can also manually trigger linting using:
+
+```bash
+pre-commit run --all-files
+```
 
 
 ## :memo: Getting started

{clarifai-11.6.8.dist-info → clarifai-11.7.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-clarifai/__init__.py,sha256=X6Ae2cXGrameIerv46p54-fULe3UApanwCJ4-JaaI_M,23
+clarifai/__init__.py,sha256=rSjRBQs9AcakQYnfj7YZFHQKbSsnq8BzM_MJeZ3UZ1M,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,12 +8,12 @@ clarifai/cli/__main__.py,sha256=7nPbLW7Jr2shkgMPvnxpn4xYGMvIcnqluJ69t9w4H_k,74
 clarifai/cli/base.py,sha256=l1WpCM9URk7mkYmHNpnZYtihbTTmMpBB5oBo9IwgeEo,10677
 clarifai/cli/compute_cluster.py,sha256=8Xss0Obrp6l1XuxJe0luOqU_pf8vXGDRi6jyIe8qR6k,2282
 clarifai/cli/deployment.py,sha256=9C4I6_kyMxRkWl6h681wc79-3mAtDHtTUaxRv05OZMs,4262
-clarifai/cli/model.py,sha256=UwlHHOfXc-Yd55TfBSOe1YgsqJNrnLPN7gAj8VgEG74,42814
+clarifai/cli/model.py,sha256=G-LcUEE0pcRVqFmz0l8n2wPRzLIx4cJcy5n8NjffoYo,43071
 clarifai/cli/nodepool.py,sha256=H6OIdUW_EiyDUwZogzEDoYmVwEjLMsgoDlPyE7gjIuU,4245
 clarifai/cli/pipeline.py,sha256=9ZWVLokXHxqXy0g1_1ACuRX20ckrzyKwnsFfuJZm6Nw,13130
 clarifai/cli/pipeline_step.py,sha256=dvoC2vAsDcxOCy88VV0X42PG22_7JSu9sfBVsk-Cix4,6133
 clarifai/cli/templates/__init__.py,sha256=HbMlZuYOMyVJde73ijNAevmSRUpIttGlHdwyO4W-JOs,44
-clarifai/cli/templates/model_templates.py,sha256=q1dKF5jHhX_1g4qtiYcEbJdWQaxCv2BSEAXI4AR2JOo,9709
+clarifai/cli/templates/model_templates.py,sha256=f3fvXTwHLBExjSOpdcEgp7X1CH28jjzpLFKljWi5arQ,9793
 clarifai/cli/templates/pipeline_step_templates.py,sha256=w1IJghF_4wWyEmHR1925N0hpGKocy3G7ezhxTH-0XCc,1716
 clarifai/cli/templates/pipeline_templates.py,sha256=l7-0yj1aw4jVZb0xjuhc9sW9LJfG3qaGqgwt7bLURCc,4462
 clarifai/client/__init__.py,sha256=MWEG_jTGn6UWbGCznsZxObJ5h65k2igD1462qID2pgI,840
@@ -24,7 +24,7 @@ clarifai/client/dataset.py,sha256=OgdpZkQ_vYmRxL8-qphcNozpvPV1bWTlte9Jv6UkKb8,35
 clarifai/client/deployment.py,sha256=QBf0tzkKBEpzNgmOEmWUJMOlVWdFEFc70Y44o8y75Gs,2875
 clarifai/client/input.py,sha256=jpX47qwn7aUBBIEuSSLHF5jk70XaWEh0prD065c9b-E,51205
 clarifai/client/lister.py,sha256=1YEm2suNxPaJO4x9V5szgD_YX6N_00vgSO-7m0HagY8,2208
-clarifai/client/model.py,sha256=DeB-es6rp0FJQVY46oO2eR_-Ux5tTmkM_qYsN1X6WcE,90793
+clarifai/client/model.py,sha256=CQP5UiHaLR2hHcG1nU-ac_utN9ZXalOzbOqaICa0VyQ,92016
 clarifai/client/model_client.py,sha256=pyPg1C3gb5Q3_DXmMmOB5AeORR1IDaaM7n0LGc3ciLk,38217
 clarifai/client/module.py,sha256=jLViQYvVV3FmRN_ivvbk83uwsx7CgYGeEx4dYAr6yD4,4537
 clarifai/client/nodepool.py,sha256=0E8-VgNMpdx2sAGotS3ZwfeUc9k3DBa3QJEJ1wKroVA,16700
@@ -35,7 +35,7 @@ clarifai/client/search.py,sha256=3LLfATrdU43a0mRNITmJV-E53bhfafZkYsbwkTtlnyU,156
 clarifai/client/user.py,sha256=-D7itPC_XCMtFnsWUOMCPU5PQd8s-ER8k-RIG2V673Y,24798
 clarifai/client/workflow.py,sha256=Bqh8lAmJcSbviJebckchTxucYlU11UQEhFSov7elpsk,13417
 clarifai/client/auth/__init__.py,sha256=7EwR0NrozkAUwpUnCsqXvE_p0wqx_SelXlSpKShKJK0,136
-clarifai/client/auth/helper.py,sha256=eitq1uQBoJ1TPjsTtbJ9g7eqT3mFm9vgc4HQR1s-zNg,16283
+clarifai/client/auth/helper.py,sha256=R_k094V79ZBDvujRhWV3kiV5EttuAsVtRQFNvOsSI8A,16290
 clarifai/client/auth/register.py,sha256=xIg1OoZ_GGnc0KQKII-R6q_cKN1JXW3BGcU2eyS-Kkc,871
 clarifai/client/auth/stub.py,sha256=nKod8eNWaBnmsaNZ59dEt42TTcwC9mMgCzEMYPZggxc,9537
 clarifai/constants/base.py,sha256=ogmFSZYoF0YhGjHg5aiOc3MLqPr_poKAls6xaD0_C3U,89
@@ -75,14 +75,14 @@ clarifai/runners/__init__.py,sha256=wXLaSljH7qLeJCrZdKEnlQh2tNqTQAIZKWOu2rZ6wGs,
 clarifai/runners/server.py,sha256=YgF-ZInjQ1DZeZ9UmK77rW35IUIXrJYa3SSm2xoXGtc,6252
 clarifai/runners/dockerfile_template/Dockerfile.template,sha256=nEnIMqzhAXDbd0Ht7QQm0U7AVPIHWQD6kYnFZ0TKJUM,2428
 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/dummy_openai_model.py,sha256=LfAJu173uTEYsN6xpaJ6TyimohyTooX16H6YYk9qVLs,8636
 clarifai/runners/models/mcp_class.py,sha256=RdKn7rW4vYol0VRDZiLTSMfkqjLhO1ijXAQ0Rq0Jfnw,6647
-clarifai/runners/models/model_builder.py,sha256=6DEwMo-Aq5CSWxTgMNgQISq2H37HXlkPauOgnmSWhZk,64704
+clarifai/runners/models/model_builder.py,sha256=N7CyOt-jP5FGJGNvarHtlmEd_O6kNXEyaRJVmSdH3MU,70929
 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=RxhYawEX6vJKTZZ_AmcHwo2ONwT7V7e3W-vXuunY7eI,11874
 clarifai/runners/models/model_servicer.py,sha256=415RqiXCPH-1WgFHrtZMDH1nb8gaQDpVlrQ_tvtbjOg,4523
-clarifai/runners/models/openai_class.py,sha256=OVYe4dWJPhskyZn53X9yJorzKZA7mjRCqYbu1rzRTFU,6715
+clarifai/runners/models/openai_class.py,sha256=KWKZKNcsGDYX6Ro2Y0kK7xcMi4YDziKRZHr_3v_g7ns,8694
 clarifai/runners/models/visual_classifier_class.py,sha256=1ZoLfCT2crrgRbejjTMAIwpTRgQMiH9N9yflOVpFxSg,2721
 clarifai/runners/models/visual_detector_class.py,sha256=ky4oFAkGCKPpGPdgaOso-n6D3HcmnbKee_8hBsNiV8U,2883
 clarifai/runners/pipeline_steps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -120,9 +120,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.6.8.dist-info/licenses/LICENSE,sha256=mUqF_d12-qE2n41g7C5_sq-BMLOcj6CNN-jevr15YHU,555
-clarifai-11.6.8.dist-info/METADATA,sha256=KPfsSo5hJ7EUSgWidOaX7PV7-JZNjtp3Qglw_doUc5E,22737
-clarifai-11.6.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-clarifai-11.6.8.dist-info/entry_points.txt,sha256=X9FZ4Z-i_r2Ud1RpZ9sNIFYuu_-9fogzCMCRUD9hyX0,51
-clarifai-11.6.8.dist-info/top_level.txt,sha256=wUMdCQGjkxaynZ6nZ9FAnvBUCgp5RJUVFSy2j-KYo0s,9
-clarifai-11.6.8.dist-info/RECORD,,
+clarifai-11.7.0.dist-info/licenses/LICENSE,sha256=mUqF_d12-qE2n41g7C5_sq-BMLOcj6CNN-jevr15YHU,555
+clarifai-11.7.0.dist-info/METADATA,sha256=AUq4ocwllb6s3rBIAqLHoIzJiYxzIYx1UnXQ7MB4ihg,23161
+clarifai-11.7.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+clarifai-11.7.0.dist-info/entry_points.txt,sha256=X9FZ4Z-i_r2Ud1RpZ9sNIFYuu_-9fogzCMCRUD9hyX0,51
+clarifai-11.7.0.dist-info/top_level.txt,sha256=wUMdCQGjkxaynZ6nZ9FAnvBUCgp5RJUVFSy2j-KYo0s,9
+clarifai-11.7.0.dist-info/RECORD,,