clarifai 11.6.4rc2__py3-none-any.whl → 11.6.6__py3-none-any.whl

clarifai/runners/models/model_runner.py

@@ -1,3 +1,4 @@
+import time
 from typing import Iterator
 
 from clarifai_grpc.grpc.api import service_pb2
@@ -6,6 +7,8 @@ from clarifai_protocol import BaseRunner
 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 ..utils.url_fetcher import ensure_urls_downloaded
 from .model_class import ModelClass
@@ -106,6 +109,20 @@ 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)
+        start_time = time.time()
+        req_id = get_req_id_from_context()
+        status_str = STATUS_UNKNOWN
+        # Endpoint is always POST /v2/.../outputs for this runner
+        endpoint = "POST /v2/.../outputs         "
+
+        # if method_name == '_GET_SIGNATURES' then the request is for getting signatures and we don't want to log it.
+        # This is a workaround to avoid logging the _GET_SIGNATURES method call.
+        method_name = None
+        logging = True
+        if len(request.inputs) > 0 and '_method_name' in request.inputs[0].data.metadata:
+            method_name = request.inputs[0].data.metadata['_method_name']
+        if method_name == '_GET_SIGNATURES':
+            logging = False
 
         resp = self.model.predict_wrapper(request)
         # if we have any non-successful code already it's an error we can return.
@@ -113,6 +130,9 @@ class ModelRunner(BaseRunner, HealthProbeRequestHandler):
             resp.status.code != status_code_pb2.SUCCESS
             and resp.status.code != status_code_pb2.ZERO
         ):
+            status_str = f"{resp.status.code} ERROR"
+            duration_ms = (time.time() - start_time) * 1000
+            logger.info(f"{endpoint} | {status_str} | {duration_ms:.2f}ms | req_id={req_id}")
             return service_pb2.RunnerItemOutput(multi_output_response=resp)
         successes = []
         for output in resp.outputs:
@@ -126,18 +146,24 @@ class ModelRunner(BaseRunner, HealthProbeRequestHandler):
                 code=status_code_pb2.SUCCESS,
                 description="Success",
             )
+            status_str = STATUS_OK
         elif any(successes):
             status = status_pb2.Status(
                 code=status_code_pb2.MIXED_STATUS,
                 description="Mixed Status",
             )
+            status_str = STATUS_MIXED
         else:
             status = status_pb2.Status(
                 code=status_code_pb2.FAILURE,
                 description="Failed",
             )
+            status_str = STATUS_FAIL
 
         resp.status.CopyFrom(status)
+        if logging:
+            duration_ms = (time.time() - start_time) * 1000
+            logger.info(f"{endpoint} | {status_str} | {duration_ms:.2f}ms | req_id={req_id}")
         return service_pb2.RunnerItemOutput(multi_output_response=resp)
 
     def runner_item_generate(
@@ -150,12 +176,21 @@ class ModelRunner(BaseRunner, HealthProbeRequestHandler):
         request = runner_item.post_model_outputs_request
         ensure_urls_downloaded(request, auth_helper=self._auth_helper)
 
+        # --- Live logging additions ---
+        start_time = time.time()
+        req_id = get_req_id_from_context()
+        status_str = STATUS_UNKNOWN
+        endpoint = "POST /v2/.../outputs/generate"
+
         for resp in self.model.generate_wrapper(request):
             # if we have any non-successful code already it's an error we can return.
             if (
                 resp.status.code != status_code_pb2.SUCCESS
                 and resp.status.code != status_code_pb2.ZERO
             ):
+                status_str = f"{resp.status.code} ERROR"
+                duration_ms = (time.time() - start_time) * 1000
+                logger.info(f"{endpoint} | {status_str} | {duration_ms:.2f}ms | req_id={req_id}")
                 yield service_pb2.RunnerItemOutput(multi_output_response=resp)
                 continue
             successes = []
@@ -170,30 +205,44 @@ class ModelRunner(BaseRunner, HealthProbeRequestHandler):
                     code=status_code_pb2.SUCCESS,
                     description="Success",
                 )
+                status_str = STATUS_OK
             elif any(successes):
                 status = status_pb2.Status(
                     code=status_code_pb2.MIXED_STATUS,
                     description="Mixed Status",
                 )
+                status_str = STATUS_MIXED
             else:
                 status = status_pb2.Status(
                     code=status_code_pb2.FAILURE,
                     description="Failed",
                 )
+                status_str = STATUS_FAIL
             resp.status.CopyFrom(status)
 
             yield service_pb2.RunnerItemOutput(multi_output_response=resp)
 
+        duration_ms = (time.time() - start_time) * 1000
+        logger.info(f"{endpoint} | {status_str} | {duration_ms:.2f}ms | req_id={req_id}")
+
     def runner_item_stream(
         self, runner_item_iterator: Iterator[service_pb2.RunnerItem]
     ) -> Iterator[service_pb2.RunnerItemOutput]:
         # Call the generate() method the underlying model implements.
+        start_time = time.time()
+        req_id = get_req_id_from_context()
+        status_str = STATUS_UNKNOWN
+        endpoint = "POST /v2/.../outputs/stream  "
+
         for resp in self.model.stream_wrapper(pmo_iterator(runner_item_iterator)):
             # if we have any non-successful code already it's an error we can return.
             if (
                 resp.status.code != status_code_pb2.SUCCESS
                 and resp.status.code != status_code_pb2.ZERO
             ):
+                status_str = f"{resp.status.code} ERROR"
+                duration_ms = (time.time() - start_time) * 1000
+                logger.info(f"{endpoint} | {status_str} | {duration_ms:.2f}ms | req_id={req_id}")
                 yield service_pb2.RunnerItemOutput(multi_output_response=resp)
                 continue
             successes = []
@@ -208,20 +257,26 @@ class ModelRunner(BaseRunner, HealthProbeRequestHandler):
                     code=status_code_pb2.SUCCESS,
                     description="Success",
                 )
+                status_str = STATUS_OK
             elif any(successes):
                 status = status_pb2.Status(
                     code=status_code_pb2.MIXED_STATUS,
                     description="Mixed Status",
                 )
+                status_str = STATUS_MIXED
             else:
                 status = status_pb2.Status(
                     code=status_code_pb2.FAILURE,
                     description="Failed",
                 )
+                status_str = STATUS_FAIL
             resp.status.CopyFrom(status)
 
             yield service_pb2.RunnerItemOutput(multi_output_response=resp)
 
+        duration_ms = (time.time() - start_time) * 1000
+        logger.info(f"{endpoint} | {status_str} | {duration_ms:.2f}ms | req_id={req_id}")
+
 
 def pmo_iterator(runner_item_iterator, auth_helper=None):
     for runner_item in runner_item_iterator:

clarifai/runners/server.py

@@ -92,6 +92,7 @@ def serve(
     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)
 
@@ -133,7 +134,28 @@ def serve(
             pat=pat,
             num_parallel_polls=num_threads,
         )
-        logger.info("Runner started successfully and is waiting for work from the API...")
+        method_signatures = 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")
         runner.start()  # start the runner to fetch work from the API.
 
 

clarifai/runners/utils/model_utils.py

@@ -68,13 +68,13 @@ def kill_process_tree(parent_pid, include_parent: bool = True, skip_pid: int = N
             logger.warning(f"Failed to kill parent process {parent_pid}: {e}")
 
 
-def execute_shell_command(
-    command: str,
-) -> subprocess.Popen:
+def execute_shell_command(command: str, stdout=None, stderr=subprocess.STDOUT) -> subprocess.Popen:
     """Execute a shell command and return its process handle.
 
     Args:
         command (str): The shell command to execute.
+        stdout : Verbose logging control,
+        stderr : Verbose error logging control
 
     Returns:
         subprocess.Popen: Process handle for the executed command.
@@ -90,7 +90,7 @@ def execute_shell_command(
     parts = shlex.split(command)
 
     try:
-        process = subprocess.Popen(parts, text=True, stderr=subprocess.STDOUT)
+        process = subprocess.Popen(parts, text=True, stdout=stdout, stderr=stderr)
 
         return process
     except subprocess.SubprocessError as e:

clarifai/runners/utils/url_fetcher.py

@@ -1,6 +1,7 @@
 import concurrent.futures
 
 import fsspec
+import requests
 
 from clarifai.utils.logging import logger
 
@@ -12,6 +13,28 @@ def download_input(input, auth_helper=None):
             _download_input_data(input.data.parts[i].data, auth_helper=auth_helper)
 
 
+def _download_with_handling(url, mode, auth_kwargs, setter, media_type):
+    fsspec_exceptions = (
+        getattr(fsspec.exceptions, 'FSTimeoutError', Exception),
+        getattr(fsspec.exceptions, 'BlocksizeMismatchError', Exception),
+    )
+    try:
+        with fsspec.open(url, mode, **auth_kwargs) as f:
+            setter(f.read())
+    except fsspec_exceptions as e:
+        logger.error(f"FSSpec error downloading {media_type} from {url}: {e}")
+        raise RuntimeError(f"FSSpec error downloading {media_type} from {url}: {e}") from e
+    except requests.RequestException as e:
+        logger.error(f"Requests error downloading {media_type} from {url}: {e}")
+        raise RuntimeError(f"Requests error downloading {media_type} from {url}: {e}") from e
+    except (IOError, OSError) as e:
+        logger.error(f"IO error downloading {media_type} from {url}: {e}")
+        raise RuntimeError(f"IO error downloading {media_type} from {url}: {e}") from e
+    except Exception as e:
+        logger.error(f"Unexpected error downloading {media_type} from {url}: {e}")
+        raise RuntimeError(f"Unexpected error downloading {media_type} from {url}: {e}") from e
+
+
 def _download_input_data(input_data, auth_helper=None):
     """
     This function will download any urls that are not already bytes.
@@ -26,21 +49,37 @@ def _download_input_data(input_data, auth_helper=None):
         auth_kwargs = _get_auth_kwargs(auth_helper)
 
     if input_data.image.url and not input_data.image.base64:
-        # Download the image
-        with fsspec.open(input_data.image.url, 'rb', **auth_kwargs) as f:
-            input_data.image.base64 = f.read()
+        _download_with_handling(
+            input_data.image.url,
+            'rb',
+            auth_kwargs,
+            lambda val: setattr(input_data.image, 'base64', val),
+            'image',
+        )
     if input_data.video.url and not input_data.video.base64:
-        # Download the video
-        with fsspec.open(input_data.video.url, 'rb', **auth_kwargs) as f:
-            input_data.video.base64 = f.read()
+        _download_with_handling(
+            input_data.video.url,
+            'rb',
+            auth_kwargs,
+            lambda val: setattr(input_data.video, 'base64', val),
+            'video',
+        )
     if input_data.audio.url and not input_data.audio.base64:
-        # Download the audio
-        with fsspec.open(input_data.audio.url, 'rb', **auth_kwargs) as f:
-            input_data.audio.base64 = f.read()
+        _download_with_handling(
+            input_data.audio.url,
+            'rb',
+            auth_kwargs,
+            lambda val: setattr(input_data.audio, 'base64', val),
+            'audio',
+        )
     if input_data.text.url and not input_data.text.raw:
-        # Download the text
-        with fsspec.open(input_data.text.url, 'r', **auth_kwargs) as f:
-            input_data.text.raw = f.read()
+        _download_with_handling(
+            input_data.text.url,
+            'r',
+            auth_kwargs,
+            lambda val: setattr(input_data.text, 'raw', val),
+            'text',
+        )
 
 
 def _get_auth_kwargs(auth_helper):

clarifai/utils/cli.py

@@ -4,6 +4,7 @@ import pkgutil
 import sys
 import typing as t
 from collections import defaultdict
+from pathlib import Path
 from typing import OrderedDict
 
 import click
@@ -205,18 +206,152 @@ def validate_context_auth(pat: str, user_id: str, api_base: str = None):
             logger.info("✅ Context is valid")
 
     except Exception as e:
-        error_msg = str(e)
-
         # Check for common authentication errors and provide user-friendly messages
-        if "PERMISSION_DENIED" in error_msg or "Unauthorized" in error_msg:
-            logger.error(f"Invalid PAT token or incorrect user ID '{user_id}': {error_msg}")
-        elif "UNAUTHENTICATED" in error_msg:
-            logger.error(f"Invalid PAT token or user ID: {error_msg}")
-        elif "SSL" in error_msg or "certificate" in error_msg:
-            logger.error(f"SSL/Certificate error: {error_msg}")
-        elif "Connection" in error_msg or "timeout" in error_msg:
-            logger.error(f"Network connection error: {error_msg}")
-        else:
-            logger.error(f"❌ Validation failed: \n{error_msg}")
-            logger.error("Please check your credentials and try again.")
+        logger.error("❌ Authentication failed. Please check your token and user ID.")
         raise click.Abort()  # Exit without saving the configuration
+
+
+def customize_ollama_model(
+    model_path, model_name=None, port=None, context_length=None, verbose=False
+):
+    """Customize the Ollama model name in the cloned template files.
+    Args:
+     model_path: Path to the cloned model directory
+     model_name: The model name to set (e.g., 'llama3.1', 'mistral') - optional
+     port: Port for Ollama server - optional
+     context_length: Context length for the model - optional
+     verbose: Whether to enable verbose logging - optional (defaults to False)
+
+    """
+    model_py_path = os.path.join(model_path, "1", "model.py")
+
+    if not os.path.exists(model_py_path):
+        logger.warning(f"Model file {model_py_path} not found, skipping model name customization")
+        return
+
+    try:
+        # Read the model.py file
+        with open(model_py_path, 'r') as file:
+            content = file.read()
+        if model_name:
+            # Replace the default model name in the load_model method
+            content = content.replace(
+                'self.model = os.environ.get("OLLAMA_MODEL_NAME", \'llama3.2\')',
+                f'self.model = os.environ.get("OLLAMA_MODEL_NAME", \'{model_name}\')',
+            )
+
+        if port:
+            # Replace the default port variable in the model.py file
+            content = content.replace("PORT = '23333'", f"PORT = '{port}'")
+
+        if context_length:
+            # Replace the default context length variable in the model.py file
+            content = content.replace(
+                "context_length = '8192'", f"context_length = '{context_length}'"
+            )
+
+        verbose_str = str(verbose)
+        if "VERBOSE_OLLAMA = True" in content:
+            content = content.replace("VERBOSE_OLLAMA = True", f"VERBOSE_OLLAMA = {verbose_str}")
+        elif "VERBOSE_OLLAMA = False" in content:
+            content = content.replace("VERBOSE_OLLAMA = False", f"VERBOSE_OLLAMA = {verbose_str}")
+
+        # Write the modified content back to model.py
+        with open(model_py_path, 'w') as file:
+            file.write(content)
+
+    except Exception as e:
+        logger.error(f"Failed to customize Ollama model name in {model_py_path}: {e}")
+        raise
+
+
+def check_ollama_installed():
+    """Check if the Ollama CLI is installed."""
+    try:
+        import subprocess
+
+        result = subprocess.run(
+            ['ollama', '--version'], capture_output=True, text=True, check=False
+        )
+        if result.returncode == 0:
+            return True
+        else:
+            return False
+    except FileNotFoundError:
+        return False
+
+
+def _is_package_installed(package_name):
+    """Helper function to check if a single package in requirements.txt is installed."""
+    import importlib.metadata
+
+    try:
+        importlib.metadata.distribution(package_name)
+        logger.debug(f"✅ {package_name} - installed")
+        return True
+    except importlib.metadata.PackageNotFoundError:
+        logger.debug(f"❌ {package_name} - not installed")
+        return False
+    except Exception as e:
+        logger.warning(f"Error checking {package_name}: {e}")
+        return False
+
+
+def parse_requirements(model_path: str):
+    """Parse requirements.txt in the model directory and return a dictionary of dependencies."""
+    from packaging.requirements import Requirement
+
+    requirements_path = Path(model_path) / "requirements.txt"
+
+    if not requirements_path.exists():
+        logger.warning(f"requirements.txt not found at {requirements_path}")
+        return []
+
+    deps = {}
+    for line in requirements_path.read_text().splitlines():
+        line = line.strip()
+        if not line or line.startswith("#"):
+            continue
+        try:
+            req = Requirement(line)
+            deps[req.name] = str(req.specifier) if req.specifier else None
+        except Exception as e:
+            logger.warning(f"⚠️ Could not parse line: {line!r} — {e}")
+    return deps
+
+
+def check_requirements_installed(model_path):
+    """Check if all dependencies in requirements.txt are installed."""
+
+    try:
+        # Getting package name and version (for logging)
+        requirements = parse_requirements(model_path)
+
+        if not requirements:
+            logger.info("No dependencies found in requirements.txt")
+            return True
+
+        logger.info(f"Checking {len(requirements)} dependencies...")
+
+        missing = [
+            full_req
+            for package_name, full_req in requirements.items()
+            if not _is_package_installed(package_name)
+        ]
+
+        if not missing:
+            logger.info(f"✅ All {len(requirements)} dependencies are installed!")
+            return True
+
+        # Report missing packages
+        logger.error(
+            f"❌ {len(missing)} of {len(requirements)} required packages are missing in the current environment"
+        )
+        logger.error("\n".join(f"  - {pkg}" for pkg in missing))
+        requirements_path = Path(model_path) / "requirements.txt"
+        logger.warning(f"To install: pip install -r {requirements_path}")
+        return False
+
+    except Exception as e:
+        logger.error(f"Failed to check requirements: {e}")
+        return False

clarifai/utils/constants.py

@@ -64,3 +64,8 @@ DEFAULT_LOCAL_RUNNER_NODEPOOL_CONFIG = {
 }
 DEFAULT_OLLAMA_MODEL_REPO = "https://github.com/Clarifai/runners-examples"
 DEFAULT_OLLAMA_MODEL_REPO_BRANCH = "ollama"
+
+STATUS_OK = "200 OK"
+STATUS_MIXED = "207 MIXED"
+STATUS_FAIL = "500 FAIL"
+STATUS_UNKNOWN = "UNKNOWN"

clarifai/utils/misc.py

@@ -78,6 +78,53 @@ def get_from_env(key: str, env_key: str) -> str:
         )
 
 
+def get_from_dict_env_or_config(key: str, env_key: str, **data) -> str:
+    """Get a value from a dictionary, environment variable, or CLI config context."""
+    # First try the provided data/kwargs
+    if key in data and data[key]:
+        return data[key]
+
+    # Then try environment variables
+    if env_key in os.environ and os.environ[env_key]:
+        return os.environ[env_key]
+
+    # Finally try CLI config context as fallback
+    try:
+        from clarifai.utils.config import Config
+        from clarifai.utils.constants import DEFAULT_CONFIG
+
+        config = Config.from_yaml(filename=DEFAULT_CONFIG)
+        current_context = config.current
+
+        # Convert env_key to the attribute name expected by Context
+        # e.g., CLARIFAI_PAT -> pat, CLARIFAI_USER_ID -> user_id, CLARIFAI_API_BASE -> api_base
+        if env_key == "CLARIFAI_PAT":
+            attr_name = "pat"
+        elif env_key == "CLARIFAI_USER_ID":
+            attr_name = "user_id"
+        elif env_key == "CLARIFAI_API_BASE":
+            attr_name = "api_base"
+        else:
+            # For other cases, convert CLARIFAI_SOMETHING to something
+            attr_name = env_key.replace("CLARIFAI_", "").lower()
+
+        if hasattr(current_context, attr_name):
+            value = getattr(current_context, attr_name)
+            if value:
+                return value
+    except Exception:
+        # If CLI config loading fails, fall through to raise error
+        pass
+
+    # If all methods fail, raise an error suggesting clarifai login
+    raise UserError(
+        f"Configuration Required. Could not find '{key}'. Please provide it in one of the following ways:\n\n"
+        f"- Pass '{key}' as a named parameter to your function.\n"
+        f"- Set the {env_key} environment variable in your environment.\n"
+        f"- Run `clarifai login` in your terminal to configure CLI authentication."
+    )
+
+
 def concept_relations_accumulation(
     relations_dict: Dict[str, Any], subject_concept: str, object_concept: str, predicate: str
 ) -> Dict[str, Any]:

{clarifai-11.6.4rc2.dist-info → clarifai-11.6.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clarifai
-Version: 11.6.4rc2
+Version: 11.6.6
 Home-page: https://github.com/Clarifai/clarifai-python
 Author: Clarifai
 Author-email: support@clarifai.com
@@ -19,7 +19,7 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: clarifai-grpc>=11.6.1
+Requires-Dist: clarifai-grpc>=11.6.6
 Requires-Dist: clarifai-protocol>=0.0.25
 Requires-Dist: numpy>=1.22.0
 Requires-Dist: tqdm>=4.65.0