clarifai 11.7.2__tar.gz → 11.7.3__tar.gz

{clarifai-11.7.2/clarifai.egg-info → clarifai-11.7.3}/PKG-INFO

@@ -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.3/clarifai/__init__.py

@@ -0,0 +1 @@
+__version__ = "11.7.3"

{clarifai-11.7.2 → clarifai-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-11.7.2 → clarifai-11.7.3}/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-11.7.2 → clarifai-11.7.3}/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-11.7.3/clarifai/runners/server.py

@@ -0,0 +1,311 @@
+"""
+This is simply the main file for the server that imports ModelRunner implementation
+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
+
+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():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        '--port',
+        type=int,
+        default=8000,
+        help="The port to host the gRPC server at.",
+        choices=range(1024, 65535),
+    )
+    parser.add_argument(
+        '--pool_size',
+        type=int,
+        default=os.environ.get('CLARIFAI_NUM_THREADS', 32),
+        help="The number of threads to use for the gRPC server. Runner (ie. grpc=False) threads are read from the config file and ModelBuilder defaults.",
+        choices=range(1, 129),
+    )  # pylint: disable=range-builtin-not-iterating
+    parser.add_argument(
+        '--max_queue_size',
+        type=int,
+        default=10,
+        help='Max queue size of requests before we begin to reject requests (default: 10).',
+        choices=range(1, 21),
+    )  # pylint: disable=range-builtin-not-iterating
+    parser.add_argument(
+        '--max_msg_length',
+        type=int,
+        default=1024 * 1024 * 1024,
+        help='Max message length of grpc requests (default: 1 GB).',
+    )
+    parser.add_argument(
+        '--enable_tls',
+        action='store_true',
+        default=False,
+        help='Set to true to enable TLS (default: False) since this server is meant for local development only.',
+    )
+    parser.add_argument(
+        '--grpc',
+        action='store_true',
+        default=False,
+        help='Set to true to start the gRPC server (default: False). If set to false, the server will not start and only the runner loop will start to fetch work from the API.',
+    )
+    parser.add_argument(
+        '--model_path',
+        type=str,
+        required=True,
+        help='The path to the model directory that contains implemention of the model.',
+    )
+
+    parsed_args = parser.parse_args()
+
+    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,
+        max_msg_length=parsed_args.max_msg_length,
+        enable_tls=parsed_args.enable_tls,
+        grpc=parsed_args.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.
+        self._servicer = ModelServicer(self._current_model)
+
+        server = GRPCServer(
+            futures.ThreadPoolExecutor(
+                max_workers=pool_size,
+                thread_name_prefix="ServeCalls",
+            ),
+            max_msg_length,
+            max_queue_size,
+        )
+        server.add_port_to_server('[::]:%s' % port, enable_tls)
+
+        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()
+
+    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.
+        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,
+            runner_id=runner_id,
+            base_url=base_url,
+            pat=pat,
+            num_parallel_polls=num_threads,
+        )
+
+        if context is None:
+            logger.debug("Context is None. Skipping code snippet generation.")
+        else:
+            method_signatures = self._builder.get_method_signatures(mocking=False)
+            from clarifai.runners.utils import code_script
+
+            snippet = code_script.generate_client_script(
+                method_signatures,
+                user_id=context.user_id,
+                app_id=context.app_id,
+                model_id=context.model_id,
+                deployment_id=context.deployment_id,
+                base_url=context.api_base,
+            )
+            logger.info(
+                "✅ Your model is running locally and is ready for requests from the API...\n"
+            )
+            logger.info(
+                f"> Code Snippet: To call your model via the API, use this code snippet:\n{snippet}"
+            )
+            logger.info(
+                f"> Playground:   To chat with your model, visit: {context.ui}/playground?model={context.model_id}__{context.model_version_id}&user_id={context.user_id}&app_id={context.app_id}\n"
+            )
+            logger.info(
+                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")
+        self._runner.start()  # start the runner to fetch work from the API.
+
+
+if __name__ == '__main__':
+    main()

{clarifai-11.7.2 → clarifai-11.7.3}/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-11.7.3/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 → clarifai-11.7.3/clarifai.egg-info}/PKG-INFO

@@ -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