clarifai 11.7.2__py3-none-any.whl → 11.7.3__py3-none-any.whl

clarifai/__init__.py

@@ -1 +1 @@
-__version__ = "11.7.2"
+__version__ = "11.7.3"

clarifai/runners/models/model_builder.py

@@ -109,7 +109,7 @@ class ModelBuilder:
         self.inference_compute_info = self._get_inference_compute_info()
         self.is_v3 = True  # Do model build for v3
 
-    def create_model_instance(self, load_model=True, mocking=False):
+    def create_model_instance(self, load_model=True, mocking=False) -> ModelClass:
         """
         Create an instance of the model class, as specified in the config file.
         """

clarifai/runners/models/model_runner.py

@@ -1,5 +1,5 @@
 import time
-from typing import Iterator
+from typing import Iterator, Optional
 
 from clarifai_grpc.grpc.api import service_pb2
 from clarifai_grpc.grpc.api.status import status_code_pb2, status_pb2
@@ -9,6 +9,7 @@ from clarifai_protocol.utils.health import HealthProbeRequestHandler
 from clarifai.client.auth.helper import ClarifaiAuthHelper
 from clarifai.utils.constants import STATUS_FAIL, STATUS_MIXED, STATUS_OK, STATUS_UNKNOWN
 from clarifai.utils.logging import get_req_id_from_context, logger
+from clarifai.utils.secrets import inject_secrets
 
 from ..utils.url_fetcher import ensure_urls_downloaded
 from .model_class import ModelClass
@@ -25,11 +26,11 @@ class ModelRunner(BaseRunner, HealthProbeRequestHandler):
         runner_id: str,
         nodepool_id: str,
         compute_cluster_id: str,
-        user_id: str = None,
+        user_id: Optional[str] = None,
         check_runner_exists: bool = True,
         base_url: str = "https://api.clarifai.com",
-        pat: str = None,
-        token: str = None,
+        pat: Optional[str] = None,
+        token: Optional[str] = None,
         num_parallel_polls: int = 4,
         **kwargs,
     ) -> None:
@@ -54,7 +55,7 @@ class ModelRunner(BaseRunner, HealthProbeRequestHandler):
         self._base_url = base_url
 
         # Create auth helper if we have sufficient authentication information
-        self._auth_helper = None
+        self._auth_helper: Optional[ClarifaiAuthHelper] = None
         if self._user_id and (self._pat or self._token):
             try:
                 self._auth_helper = ClarifaiAuthHelper(
@@ -109,6 +110,7 @@ class ModelRunner(BaseRunner, HealthProbeRequestHandler):
             raise Exception("Unexpected work item type: {}".format(runner_item))
         request = runner_item.post_model_outputs_request
         ensure_urls_downloaded(request, auth_helper=self._auth_helper)
+        inject_secrets(request)
         start_time = time.time()
         req_id = get_req_id_from_context()
         status_str = STATUS_UNKNOWN
@@ -175,6 +177,7 @@ class ModelRunner(BaseRunner, HealthProbeRequestHandler):
             raise Exception("Unexpected work item type: {}".format(runner_item))
         request = runner_item.post_model_outputs_request
         ensure_urls_downloaded(request, auth_helper=self._auth_helper)
+        inject_secrets(request)
 
         # --- Live logging additions ---
         start_time = time.time()
@@ -277,10 +280,15 @@ class ModelRunner(BaseRunner, HealthProbeRequestHandler):
         duration_ms = (time.time() - start_time) * 1000
         logger.info(f"{endpoint} | {status_str} | {duration_ms:.2f}ms | req_id={req_id}")
 
+    def set_model(self, model: ModelClass):
+        """Set the model for this runner."""
+        self.model = model
+
 
 def pmo_iterator(runner_item_iterator, auth_helper=None):
     for runner_item in runner_item_iterator:
         if not runner_item.HasField('post_model_outputs_request'):
             raise Exception("Unexpected work item type: {}".format(runner_item))
         ensure_urls_downloaded(runner_item.post_model_outputs_request, auth_helper=auth_helper)
+        inject_secrets(runner_item.post_model_outputs_request)
         yield runner_item.post_model_outputs_request

clarifai/runners/models/model_servicer.py

@@ -6,6 +6,7 @@ from clarifai_grpc.grpc.api import service_pb2, service_pb2_grpc
 from clarifai_grpc.grpc.api.status import status_code_pb2, status_pb2
 
 from clarifai.client.auth.helper import ClarifaiAuthHelper
+from clarifai.utils.secrets import inject_secrets
 
 from ..utils.url_fetcher import ensure_urls_downloaded
 
@@ -56,6 +57,7 @@ class ModelServicer(service_pb2_grpc.V2Servicer):
 
         # Download any urls that are not already bytes.
         ensure_urls_downloaded(request, auth_helper=self._auth_helper)
+        inject_secrets(request)
 
         try:
             return self.model.predict_wrapper(request)
@@ -80,6 +82,7 @@ class ModelServicer(service_pb2_grpc.V2Servicer):
         """
         # Download any urls that are not already bytes.
         ensure_urls_downloaded(request, auth_helper=self._auth_helper)
+        inject_secrets(request)
 
         try:
             yield from self.model.generate_wrapper(request)
@@ -108,6 +111,7 @@ class ModelServicer(service_pb2_grpc.V2Servicer):
         # Download any urls that are not already bytes.
         for req in request:
             ensure_urls_downloaded(req, auth_helper=self._auth_helper)
+            inject_secrets(req)
 
         try:
             yield from self.model.stream_wrapper(request_copy)
@@ -122,3 +126,6 @@ class ModelServicer(service_pb2_grpc.V2Servicer):
                     internal_details=str(e),
                 )
             )
+
+    def set_model(self, model):
+        self.model = model

clarifai/runners/server.py

@@ -6,6 +6,7 @@ and starts the server.
 import argparse
 import os
 from concurrent import futures
+from typing import Optional
 
 from clarifai_grpc.grpc.api import service_pb2_grpc
 from clarifai_protocol.utils.grpc_server import GRPCServer
@@ -14,6 +15,7 @@ from clarifai.runners.models.model_builder import ModelBuilder
 from clarifai.runners.models.model_runner import ModelRunner
 from clarifai.runners.models.model_servicer import ModelServicer
 from clarifai.utils.logging import logger
+from clarifai.utils.secrets import get_secrets_path, load_secrets, start_secrets_watcher
 
 
 def main():
@@ -66,8 +68,8 @@ def main():
 
     parsed_args = parser.parse_args()
 
-    serve(
-        model_path=parsed_args.model_path,
+    server = ModelServer(parsed_args.model_path)
+    server.serve(
         port=parsed_args.port,
         pool_size=parsed_args.pool_size,
         max_queue_size=parsed_args.max_queue_size,
@@ -77,35 +79,160 @@ def main():
     )
 
 
-def serve(
-    model_path,
-    port=8000,
-    pool_size=32,
-    num_threads=0,
-    max_queue_size=10,
-    max_msg_length=1024 * 1024 * 1024,
-    enable_tls=False,
-    grpc=False,
-    user_id: str = os.environ.get("CLARIFAI_USER_ID", None),
-    compute_cluster_id: str = os.environ.get("CLARIFAI_COMPUTE_CLUSTER_ID", None),
-    nodepool_id: str = os.environ.get("CLARIFAI_NODEPOOL_ID", None),
-    runner_id: str = os.environ.get("CLARIFAI_RUNNER_ID", None),
-    base_url: str = os.environ.get("CLARIFAI_API_BASE", "https://api.clarifai.com"),
-    pat: str = os.environ.get("CLARIFAI_PAT", None),
-    context=None,  # This is the current context object that contains user_id, app_id, model_id, etc.
-):
-    builder = ModelBuilder(model_path, download_validation_only=True)
-
-    model = builder.create_model_instance()
-
-    # `num_threads` can be set in config.yaml or via the environment variable CLARIFAI_NUM_THREADS="<integer>".
-    # Note: The value in config.yaml takes precedence over the environment variable.
-    if num_threads == 0:
-        num_threads = builder.config.get("num_threads")
-    # Setup the grpc server for local development.
-    if grpc:
+class ModelServer:
+    def __init__(self, model_path):
+        self.model_path = model_path
+        self._servicer = None
+        self._runner = None
+        self._secrets_path = get_secrets_path()
+        self._watcher_thread = None
+
+        # Initialize secrets system with enhanced validation
+        self._initialize_secrets_system()
+
+        # Build model after secrets are loaded
+        self._builder = ModelBuilder(model_path, download_validation_only=True)
+        self._current_model = self._builder.create_model_instance()
+        logger.info("ModelServer initialized successfully")
+
+    def _initialize_secrets_system(self):
+        """Initialize the secrets management system with comprehensive validation."""
+        if not self._secrets_path:
+            logger.info("No secrets path configured, running without secrets")
+            return
+
+        logger.info(f"Initializing secrets system with path: {self._secrets_path}")
+
+        # Load existing secrets if directory exists
+        if self._secrets_path.exists():
+            try:
+                loaded_secrets = load_secrets(self._secrets_path)
+                if loaded_secrets:
+                    logger.info(f"Loaded {len(loaded_secrets)} initial secrets")
+                else:
+                    logger.info("Secrets directory exists but contains no valid secrets")
+            except Exception as e:
+                logger.error(f"Error loading initial secrets: {e}")
+        else:
+            logger.info(f"Secrets directory does not exist yet: {self._secrets_path}")
+
+        # Always start the watcher regardless of current directory state
+        # This handles the case where secrets are mounted after server startup
+        try:
+            self._watcher_thread = start_secrets_watcher(
+                self._secrets_path, self.reload_model_on_secrets_change, interval=10.0
+            )
+            logger.info("Secrets watcher started successfully")
+        except Exception as e:
+            logger.error(f"Failed to start secrets watcher: {e}")
+            # Don't fail server startup if watcher fails
+            self._watcher_thread = None
+
+    def reload_model_on_secrets_change(self) -> None:
+        """Reload model and environment secrets when the secrets directory changes.
+
+        This method implements a robust reload strategy with comprehensive error handling
+        and component state management.
+        """
+        logger.info("Detected secrets change, initiating model reload sequence...")
+
+        # Step 1: Reload secrets from filesystem
+        if self._secrets_path is not None:
+            try:
+                loaded_secrets = load_secrets(self._secrets_path)
+                if loaded_secrets:
+                    logger.info(f"Reloaded {len(loaded_secrets)} secrets")
+                else:
+                    logger.warning("No secrets loaded during reload")
+            except Exception as e:
+                logger.error(f"Failed to reload secrets: {e}")
+                return
+
+        # Step 2: Rebuild model instance
+        if self._builder is not None:
+            try:
+                logger.info("Rebuilding model instance...")
+                self._current_model = self._builder.create_model_instance()
+                logger.info("Model instance rebuilt successfully")
+            except Exception as e:
+                logger.error(f"Failed to rebuild model instance: {e}")
+                # Keep the previous model instance if rebuild fails
+                return
+
+        # Step 3: Update servicer with new model
+        if self._servicer and self._current_model:
+            try:
+                self._servicer.set_model(self._current_model)
+                logger.info("Updated servicer with new model instance")
+            except Exception as e:
+                logger.error(f"Failed to update servicer with new model: {e}")
+
+        # Step 4: Update runner with new model
+        if self._runner and self._current_model:
+            try:
+                self._runner.set_model(self._current_model)
+                logger.info("Updated runner with new model instance")
+            except Exception as e:
+                logger.error(f"Failed to update runner with new model: {e}")
+
+        logger.info("Model reload sequence completed successfully")
+
+    def shutdown(self):
+        """Gracefully shutdown the server and cleanup resources."""
+        logger.info("Shutting down ModelServer...")
+
+        # Stop the watcher thread
+        if self._watcher_thread and self._watcher_thread.is_alive():
+            logger.info("Stopping secrets watcher...")
+            # Note: Since it's a daemon thread, it will stop when main process exits
+        logger.info("ModelServer shutdown completed")
+
+    def serve(
+        self,
+        port=8000,
+        pool_size=32,
+        num_threads=0,
+        max_queue_size=10,
+        max_msg_length=1024 * 1024 * 1024,
+        enable_tls=False,
+        grpc=False,
+        user_id: Optional[str] = os.environ.get("CLARIFAI_USER_ID", None),
+        compute_cluster_id: Optional[str] = os.environ.get("CLARIFAI_COMPUTE_CLUSTER_ID", None),
+        nodepool_id: Optional[str] = os.environ.get("CLARIFAI_NODEPOOL_ID", None),
+        runner_id: Optional[str] = os.environ.get("CLARIFAI_RUNNER_ID", None),
+        base_url: Optional[str] = os.environ.get("CLARIFAI_API_BASE", "https://api.clarifai.com"),
+        pat: Optional[str] = os.environ.get("CLARIFAI_PAT", None),
+        context=None,  # This is the current context object that contains user_id, app_id, model_id, etc.
+    ):
+        # `num_threads` can be set in config.yaml or via the environment variable CLARIFAI_NUM_THREADS="<integer>".
+        # Note: The value in config.yaml takes precedence over the environment variable.
+        if num_threads == 0:
+            num_threads = self._builder.config.get("num_threads")
+        # Setup the grpc server for local development.
+        if grpc:
+            self.start_servicer(
+                port,
+                pool_size,
+                max_queue_size,
+                max_msg_length,
+                enable_tls,
+            )
+        else:
+            # start the runner with the proper env variables and as a runner protocol.
+            self.start_runner(
+                context,
+                compute_cluster_id,
+                user_id,
+                nodepool_id,
+                runner_id,
+                base_url,
+                pat,
+                num_threads,
+            )
+
+    def start_servicer(self, port, pool_size, max_queue_size, max_msg_length, enable_tls):
         # initialize the servicer with the runner so that it gets the predict(), generate(), stream() classes.
-        servicer = ModelServicer(model)
+        self._servicer = ModelServicer(self._current_model)
 
         server = GRPCServer(
             futures.ThreadPoolExecutor(
@@ -117,15 +244,30 @@ def serve(
         )
         server.add_port_to_server('[::]:%s' % port, enable_tls)
 
-        service_pb2_grpc.add_V2Servicer_to_server(servicer, server)
+        service_pb2_grpc.add_V2Servicer_to_server(self._servicer, server)
         server.start()
         logger.info("Started server on port %s", port)
         logger.info(f"Access the model at http://localhost:{port}")
         server.wait_for_termination()
-    else:  # start the runner with the proper env variables and as a runner protocol.
+
+    def start_runner(
+        self,
+        context,
+        compute_cluster_id,
+        user_id,
+        nodepool_id,
+        runner_id,
+        base_url,
+        pat,
+        num_threads,
+    ):
         # initialize the Runner class. This is what the user implements.
-        runner = ModelRunner(
-            model=model,
+        assert compute_cluster_id is not None, "compute_cluster_id must be set for the runner."
+        assert nodepool_id is not None, "nodepool_id must be set for the runner"
+        assert runner_id is not None, "runner_id must be set for the runner."
+        assert base_url is not None, "base_url must be set for the runner."
+        self._runner = ModelRunner(
+            model=self._current_model,
             user_id=user_id,
             compute_cluster_id=compute_cluster_id,
             nodepool_id=nodepool_id,
@@ -138,7 +280,7 @@ def serve(
         if context is None:
             logger.debug("Context is None. Skipping code snippet generation.")
         else:
-            method_signatures = builder.get_method_signatures(mocking=False)
+            method_signatures = self._builder.get_method_signatures(mocking=False)
             from clarifai.runners.utils import code_script
 
             snippet = code_script.generate_client_script(
@@ -162,7 +304,7 @@ def serve(
                 f"> API URL:      To call your model via the API, use this model URL: {context.ui}/users/{context.user_id}/apps/{context.app_id}/models/{context.model_id}\n"
             )
             logger.info("Press CTRL+C to stop the runner.\n")
-        runner.start()  # start the runner to fetch work from the API.
+        self._runner.start()  # start the runner to fetch work from the API.
 
 
 if __name__ == '__main__':

clarifai/runners/utils/loader.py

@@ -71,6 +71,7 @@ class HuggingFaceLoader:
                         self.ignore_patterns.extend(ignore_file_patterns)
                     else:
                         self.ignore_patterns = ignore_file_patterns
+
                 snapshot_download(
                     repo_id=self.repo_id,
                     local_dir=checkpoint_path,
@@ -196,6 +197,7 @@ class HuggingFaceLoader:
         if any(f.endswith(".safetensors") for f in repo_files):
             self.ignore_patterns = [
                 "**/original/*",
+                "original/*",
                 "**/*.pth",
                 "**/*.bin",
                 "*.pth",

clarifai/utils/secrets.py

@@ -0,0 +1,214 @@
+import os
+import time
+from pathlib import Path
+from threading import Thread
+from typing import Any, Callable, Optional
+
+from clarifai_grpc.grpc.api import resources_pb2, service_pb2
+from google.protobuf import struct_pb2
+from google.protobuf.json_format import MessageToDict
+
+from clarifai.utils.logging import logger
+
+
+def get_secrets_path() -> Optional[Path]:
+    path = os.environ.get("CLARIFAI_SECRETS_PATH", None)
+    return Path(path) if path else None
+
+
+def load_secrets(path: Path) -> Optional[dict[str, str]]:
+    """load_secrets reads .env style secret files, sets them as environment variables, and
+    returns the added variables.
+    Args:
+        path (Path): Path to the directory containing secrets files.
+    Returns:
+        dict[str, str] | None: Dict of loaded environment variables, or None if the file does not exist.
+    """
+    variables = get_env_variable(path)
+    if variables is not None:
+        set_env_variable(variables)
+        return variables
+    return None
+
+
+def set_env_variable(variables: dict[str, str]) -> None:
+    for key, value in variables.items():
+        os.environ[key] = value
+
+
+def get_env_variable(path: Path) -> Optional[dict[str, str]]:
+    """get_env_variable reads .env style secret files and returns variables to be added to the environment.
+    Args:
+        path (Path): Path to the secrets directory.
+    Returns:
+        dict[str, str] | None: Dictionary of environment variable keys and values, or None if the files do not exist.
+    """
+    if not path.exists() or not path.is_dir():
+        return None
+    loaded_keys = {}
+    for secret_dir in path.iterdir():
+        if not secret_dir.is_dir():
+            continue
+        secrets_file_path = secret_dir / secret_dir.name
+        if secrets_file_path.exists() and secrets_file_path.is_file():
+            secrets = read_secrets_file(secrets_file_path)
+            if secrets:
+                loaded_keys.update(secrets)
+    return loaded_keys
+
+
+def read_secrets_file(path: Path) -> Optional[dict[str, str]]:
+    """Read secrets from a single .env formatted file with robust error handling."""
+    if not path.exists() or not path.is_file():
+        logger.warning(f"Secret file does not exist or is not a file: {path}")
+        return None
+    loaded_keys = {}
+    try:
+        with open(path, 'r', encoding='utf-8') as f:
+            for line_num, line in enumerate(f, 1):
+                line = line.strip()
+                if not line or line.startswith('#'):
+                    continue
+                if '=' not in line:
+                    logger.warning(f"Invalid line format in {path}:{line_num}: {line}")
+                    continue
+                key, value = line.split('=', 1)
+                key = key.strip()
+                value = value.strip().strip('"').strip("'")
+                if key:  # Only add non-empty keys
+                    loaded_keys[key] = value
+                    logger.debug(f"Loaded secret key: {key}")
+    except (IOError, OSError, UnicodeDecodeError) as e:
+        logger.error(f"Error reading secrets file {path}: {e}")
+        return None
+    except Exception as e:
+        logger.error(f"Unexpected error reading secrets file {path}: {e}")
+        return None
+
+    return loaded_keys if loaded_keys else None
+
+
+def start_secrets_watcher(
+    secrets_path: Path, reload_callback: Callable, interval: float = 10
+) -> Thread:
+    """start_secrets_watcher starts a background thread that watches the secret file directory for changes
+    and calls the reload_callback when changes are detected.
+
+    Args:
+        secrets_path (Path): Path to the secrets file directory.
+        reload_callback (Callable): Callback function to call when the file changes.
+        interval (float, optional): Interval to wait before checking again. Defaults to 10.
+    """
+
+    def watch_loop():
+        previous_state = None
+
+        while True:
+            current_state = {}
+
+            # Build current state of all secret files
+            if secrets_path.exists():
+                for secret_dir in secrets_path.iterdir():
+                    if not secret_dir.is_dir():
+                        continue
+                    try:
+                        filepath = secret_dir / secret_dir.name
+                        if filepath.exists() and filepath.is_file():
+                            current_state[secret_dir.name] = filepath.stat().st_mtime
+                    except Exception as e:
+                        logger.error(f"Error checking secret file {secret_dir.name}: {e}")
+
+            # Trigger callback if state changed (but not on first run)
+            if previous_state is not None and current_state != previous_state:
+                try:
+                    logger.info("Secrets changed, calling reload callback...")
+                    reload_callback()
+                except Exception as e:
+                    logger.error(f"Error in reload callback: {e}")
+
+            previous_state = current_state
+            time.sleep(interval)
+
+    watcher_thread = Thread(target=watch_loop, daemon=True)
+    watcher_thread.start()
+    return watcher_thread
+
+
+def inject_secrets(request: Optional[service_pb2.PostModelOutputsRequest]) -> None:
+    """inject_secrets injects secrets into the request's model version output info params.
+    The request is modified in place.
+
+    Args:
+        request (service_pb2.PostModelOutputsRequest): The request to inject secrets into.
+    """
+    if request is None:
+        return
+
+    if secrets_path := get_secrets_path():
+        # Since only env type secrets are injected into the shared volume, we can read them directly.
+        variables = get_env_variable(secrets_path)
+    else:
+        # If no secrets path is set, assume no secrets and return the request as is.
+        return
+
+    if not request.HasField("model"):
+        request.model.CopyFrom(resources_pb2.Model())
+    if not request.model.HasField("model_version"):
+        request.model.model_version.CopyFrom(resources_pb2.ModelVersion())
+    if not request.model.model_version.HasField("output_info"):
+        request.model.model_version.output_info.CopyFrom(resources_pb2.OutputInfo())
+    if not request.model.model_version.output_info.HasField("params"):
+        request.model.model_version.output_info.params.CopyFrom(struct_pb2.Struct())
+
+    if variables:
+        request.model.model_version.output_info.params.update(variables)
+    return
+
+
+def get_secrets(
+    request: Optional[service_pb2.PostModelOutputsRequest],
+) -> dict[str, Any]:
+    """get_secrets extracts and returns the secrets from the request's model version output info params and environment.
+
+    Args:
+        request (Optional[service_pb2.PostModelOutputsRequest]): The request from which to extract secrets.
+    """
+    params = {}
+    env_params = {}
+    req_params = {}
+
+    if request is not None:
+        req_params = get_request_secrets(request)
+
+    if secrets_path := get_secrets_path():
+        # Since only env type secrets are injected into the shared volume, we can read them directly.
+        env_params = get_env_variable(secrets_path)
+    if env_params:
+        params.update(env_params)
+    if req_params:
+        params.update(req_params)
+    return params
+
+
+def get_request_secrets(request: service_pb2.PostModelOutputsRequest) -> Optional[dict[str, Any]]:
+    if (
+        request.HasField("model")
+        and request.model.HasField("model_version")
+        and request.model.model_version.HasField("output_info")
+        and request.model.model_version.output_info.HasField("params")
+    ):
+        return MessageToDict(request.model.model_version.output_info.params)
+    return None
+
+
+def get_secret(param_name: str) -> Optional[str]:
+    """get_secret retrieves a secret value from environment variables
+    Args:
+        param_name (str): Name of the secret to retrieve.
+    Returns:
+        Optional[str]: The value of the secret if found, otherwise None.
+    """
+    env_value = os.environ.get(param_name) or os.environ.get(param_name.upper())
+    if env_value:
+        return env_value
+    return None

{clarifai-11.7.2.dist-info → clarifai-11.7.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clarifai
-Version: 11.7.2
+Version: 11.7.3
 Home-page: https://github.com/Clarifai/clarifai-python
 Author: Clarifai
 Author-email: support@clarifai.com

{clarifai-11.7.2.dist-info → clarifai-11.7.3.dist-info}/RECORD

@@ -1,4 +1,4 @@
-clarifai/__init__.py,sha256=6gn-LTh3dEaW8xtpYwCmhIveFTKvM01jgLce36FaA10,23
+clarifai/__init__.py,sha256=_FaWaMw60Ev9qRDuhSRxnEdoOpDJsOwg5mXJ6pRLesQ,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
@@ -72,16 +72,16 @@ clarifai/rag/__init__.py,sha256=wu3PzAzo7uqgrEzuaC9lY_3gj1HFiR3GU3elZIKTT5g,40
 clarifai/rag/rag.py,sha256=EG3GoFrHFCmA70Tz49_0Jo1-3WIaHSgWGHecPeErcdc,14170
 clarifai/rag/utils.py,sha256=_gVZdABuMnraCKViLruV75x0F3IpgFXN6amYSGE5_xc,4462
 clarifai/runners/__init__.py,sha256=wXLaSljH7qLeJCrZdKEnlQh2tNqTQAIZKWOu2rZ6wGs,279
-clarifai/runners/server.py,sha256=B8cNLCRVWUtSmPUYTReyi3g8rKh5iDrePhp28CzUyoY,6413
+clarifai/runners/server.py,sha256=ZsPx9xInP6b_-KnH6M__PyVnU7Jlj1Iec6ycS6hPnGI,12453
 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=LfAJu173uTEYsN6xpaJ6TyimohyTooX16H6YYk9qVLs,8636
 clarifai/runners/models/mcp_class.py,sha256=RdKn7rW4vYol0VRDZiLTSMfkqjLhO1ijXAQ0Rq0Jfnw,6647
-clarifai/runners/models/model_builder.py,sha256=nAu2H2I8PQiGeFGULwWKhlBX19QYI6sOmjwD3TrjxB0,70943
+clarifai/runners/models/model_builder.py,sha256=sG28Skk1FmHk6OY50T2n3aGVlFvWYJ4MtObozgz8kL0,70957
 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/model_runner.py,sha256=91Phib3REIkrf9hRVjEfUJq2DR4yl_HA9SdUAEmg_3o,12238
+clarifai/runners/models/model_servicer.py,sha256=ZNF5rFI76YCmXXQIrz4wacPMtlFfl2KRsmPw29luGKI,4729
 clarifai/runners/models/openai_class.py,sha256=v3R1CoUIeS9dh9jhGH7G7Jih9DLXkHvieQLjMtC4Gas,8892
 clarifai/runners/models/visual_classifier_class.py,sha256=1ZoLfCT2crrgRbejjTMAIwpTRgQMiH9N9yflOVpFxSg,2721
 clarifai/runners/models/visual_detector_class.py,sha256=ky4oFAkGCKPpGPdgaOso-n6D3HcmnbKee_8hBsNiV8U,2883
@@ -93,7 +93,7 @@ clarifai/runners/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3
 clarifai/runners/utils/code_script.py,sha256=zZ5xjd13z2oV4CUWgMU0w6J6dRr01Kl2K-8pPyw0MiY,14346
 clarifai/runners/utils/const.py,sha256=MK7lTzzJKbOiyiUtG_jlJXfz_xNKMn5LjkQ9vjbttXE,1538
 clarifai/runners/utils/data_utils.py,sha256=HRpMYR2O0OiDpXXhOManLHTeomC4bFnXMHVAiT_12yE,20856
-clarifai/runners/utils/loader.py,sha256=K5Y8MPbIe5STw2gDnrL8KqFgKNxEo7bz-RV0ip1T4PM,10900
+clarifai/runners/utils/loader.py,sha256=C6mI-9SgmdFM18Rcra7UuisE8ErHa5WlSxsM-SKucnA,10931
 clarifai/runners/utils/method_signatures.py,sha256=qdHaO8ZIgP6BBXXMhMPhcQ46dse-XMP2t4VJCNG7O3Q,18335
 clarifai/runners/utils/model_utils.py,sha256=MCYhV_00anptIO1Qtxgzn3DlGI2UHV0ESFT3wLNcAMM,6413
 clarifai/runners/utils/openai_convertor.py,sha256=ZlIrvvfHttD_DavLvmKZdL8gNq_TQvQtZVnYamwdWz4,8248
@@ -112,6 +112,7 @@ clarifai/utils/logging.py,sha256=0we53uTqUvzrulC86whu-oeWNxn1JjJL0OQ98Bwf9vo,151
 clarifai/utils/misc.py,sha256=ld7_lls4CrjHzKchsSgJs4T-rVpUVEzRy4MDWBEQlyA,22812
 clarifai/utils/model_train.py,sha256=0XSAoTkSsrwf4f-W9yw2mkXZtkal7LBLJSoi86CFCn4,9250
 clarifai/utils/protobuf.py,sha256=VMhnNsPuWQ16VarKm8BOr5zccXMe26UlrxdJxIzEZNM,6220
+clarifai/utils/secrets.py,sha256=HAnkEXp16lPGpm19D6Aw0i-_aOWsGgQF8Vvej45_rVA,8076
 clarifai/utils/evaluation/__init__.py,sha256=PYkurUrXrGevByj7RFb6CoU1iC7fllyQSfnnlo9WnY8,69
 clarifai/utils/evaluation/helpers.py,sha256=0t6eIDXeZEoiVvnmHTnsIF_-v4BzrQW1hFaqc_psifU,21079
 clarifai/utils/evaluation/main.py,sha256=N_sfRuMjHrUeuWN0Pzms65M1PbkQkgYg3WoQVaDR1Jw,17764
@@ -120,9 +121,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.7.2.dist-info/licenses/LICENSE,sha256=mUqF_d12-qE2n41g7C5_sq-BMLOcj6CNN-jevr15YHU,555
-clarifai-11.7.2.dist-info/METADATA,sha256=-lB70fchjL4QxbV6k4CHm4rVpyqwkFaP6YAmBPzFByI,23161
-clarifai-11.7.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-clarifai-11.7.2.dist-info/entry_points.txt,sha256=X9FZ4Z-i_r2Ud1RpZ9sNIFYuu_-9fogzCMCRUD9hyX0,51
-clarifai-11.7.2.dist-info/top_level.txt,sha256=wUMdCQGjkxaynZ6nZ9FAnvBUCgp5RJUVFSy2j-KYo0s,9
-clarifai-11.7.2.dist-info/RECORD,,
+clarifai-11.7.3.dist-info/licenses/LICENSE,sha256=mUqF_d12-qE2n41g7C5_sq-BMLOcj6CNN-jevr15YHU,555
+clarifai-11.7.3.dist-info/METADATA,sha256=HWiJ7iGKy1IcBF23sc07GMC0RRAW7varrYy1Koa5n_Y,23161
+clarifai-11.7.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+clarifai-11.7.3.dist-info/entry_points.txt,sha256=X9FZ4Z-i_r2Ud1RpZ9sNIFYuu_-9fogzCMCRUD9hyX0,51
+clarifai-11.7.3.dist-info/top_level.txt,sha256=wUMdCQGjkxaynZ6nZ9FAnvBUCgp5RJUVFSy2j-KYo0s,9
+clarifai-11.7.3.dist-info/RECORD,,