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

clarifai/client/auth/helper.py

@@ -2,6 +2,7 @@ import os
 import urllib.request
 from typing import Any, Dict
 
+import grpc
 from clarifai_grpc.channel.clarifai_channel import ClarifaiChannel
 from clarifai_grpc.grpc.api import resources_pb2, service_pb2_grpc
 
@@ -289,7 +290,11 @@ class ClarifaiAuthHelper:
             )
 
     def get_stub(self) -> service_pb2_grpc.V2Stub:
-        """Get the API gRPC stub using the right channel based on the API endpoint base.
+        stub, channel = self.get_stub_and_channel()
+        return stub
+
+    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:
           stub: The service_pb2_grpc.V2Stub stub for the API.
@@ -310,7 +315,7 @@ class ClarifaiAuthHelper:
                 port = 80
             channel = ClarifaiChannel.get_insecure_grpc_channel(base=host, port=port)
         stub = service_pb2_grpc.V2Stub(channel)
-        return stub
+        return stub, channel
 
     def get_async_stub(self) -> service_pb2_grpc.V2Stub:
         """Get the API gRPC async stub using the right channel based on the API endpoint base.

clarifai/client/base.py

@@ -11,7 +11,7 @@ from clarifai.client.auth.helper import ClarifaiAuthHelper
 from clarifai.constants.base import COMPUTE_ORCHESTRATION_RESOURCES
 from clarifai.errors import ApiError, UserError
 from clarifai.utils.constants import CLARIFAI_PAT_ENV_VAR, CLARIFAI_SESSION_TOKEN_ENV_VAR
-from clarifai.utils.misc import get_from_dict_or_env
+from clarifai.utils.misc import get_from_dict_env_or_config
 
 
 class BaseClient:
@@ -39,15 +39,42 @@ class BaseClient:
     def __init__(self, **kwargs):
         token, pat = "", ""
         try:
-            pat = get_from_dict_or_env(key="pat", env_key=CLARIFAI_PAT_ENV_VAR, **kwargs)
+            pat = get_from_dict_env_or_config(key="pat", env_key=CLARIFAI_PAT_ENV_VAR, **kwargs)
         except UserError:
-            token = get_from_dict_or_env(
-                key="token", env_key=CLARIFAI_SESSION_TOKEN_ENV_VAR, **kwargs
-            )
+            try:
+                token = get_from_dict_env_or_config(
+                    key="token", env_key=CLARIFAI_SESSION_TOKEN_ENV_VAR, **kwargs
+                )
+            except UserError:
+                pass
         finally:
-            assert token or pat, Exception(
-                "Need 'pat' or 'token' in args or use one of the CLARIFAI_PAT or CLARIFAI_SESSION_TOKEN env vars"
-            )
+            if not (token or pat):
+                raise UserError(
+                    "Authentication Required. Please authenticate in one of the following ways:\n\n"
+                    "- Pass your Personal Access Token ('pat') or session token ('token') as arguments to your function.\n"
+                    "- Set the CLARIFAI_PAT or CLARIFAI_SESSION_TOKEN environment variables in your environment.\n"
+                    "- Run `clarifai login` in your terminal to configure CLI authentication."
+                )
+
+        # Also try to get user_id and base from CLI config if not provided
+        if not kwargs.get('user_id'):
+            try:
+                user_id = get_from_dict_env_or_config(
+                    key="user_id", env_key="CLARIFAI_USER_ID", **kwargs
+                )
+                kwargs['user_id'] = user_id
+            except UserError:
+                pass  # user_id is optional for some use cases
+
+        if not kwargs.get('base'):
+            try:
+                base = get_from_dict_env_or_config(
+                    key="base", env_key="CLARIFAI_API_BASE", **kwargs
+                )
+                kwargs['base'] = base
+            except UserError:
+                pass  # base has a default value
+
         kwargs.update({'token': token, 'pat': pat})
 
         self.auth_helper = ClarifaiAuthHelper(**kwargs, validate=False)

clarifai/client/compute_cluster.py

@@ -165,7 +165,7 @@ class ComputeCluster(Lister, BaseClient):
         response = self._grpc_request(self.STUB.PostNodepools, request)
         if response.status.code != status_code_pb2.SUCCESS:
             raise Exception(response.status)
-        self.logger.info("\nNodepool created\n%s", response.status)
+        self.logger.info(f"Nodepool with ID '{nodepool_id}' is created:\n{response.status}")
 
         dict_response = MessageToDict(response.nodepools[0], preserving_proto_field_name=True)
         kwargs = self.process_response_keys(dict_response, 'nodepool')

clarifai/client/model.py

@@ -445,7 +445,9 @@ class Model(Lister, BaseClient):
         response = self._grpc_request(self.STUB.PostModelVersions, request)
         if response.status.code != status_code_pb2.SUCCESS:
             raise Exception(response.status)
-        self.logger.info("\nModel Version created\n%s", response.status)
+        self.logger.info(
+            f"Model Version with ID '{response.model.model_version.id}' is created:\n{response.status}"
+        )
 
         kwargs.update({'app_id': self.app_id, 'user_id': self.user_id})
         dict_response = MessageToDict(response, preserving_proto_field_name=True)

clarifai/client/nodepool.py

@@ -195,7 +195,9 @@ class Nodepool(Lister, BaseClient):
         response = self._grpc_request(self.STUB.PostDeployments, request)
         if response.status.code != status_code_pb2.SUCCESS:
             raise Exception(response.status)
-        self.logger.info("\nDeployment created\n%s", response.status)
+        self.logger.info(
+            f"Deployment with ID '{response.deployments[0].id}' is created:\n{response.status}"
+        )
 
         dict_response = MessageToDict(
             response.deployments[0], preserving_proto_field_name=True, use_integers_for_enums=True
@@ -324,7 +326,7 @@ class Nodepool(Lister, BaseClient):
         if response.status.code != status_code_pb2.SUCCESS:
             raise Exception(response.status)
         self.logger.info(
-            "\nRunner created\n%s with id: %s", response.status, response.runners[0].id
+            f"Runner with ID '{response.runners[0].id}' is created:\n{response.status}"
         )
 
         dict_response = MessageToDict(response.runners[0], preserving_proto_field_name=True)

clarifai/client/user.py

@@ -177,7 +177,7 @@ class User(Lister, BaseClient):
         response = self._grpc_request(self.STUB.PostApps, request)
         if response.status.code != status_code_pb2.SUCCESS:
             raise Exception(response.status)
-        self.logger.info("\nApp created\n%s", response.status)
+        self.logger.info(f"App with ID '{app_id}' is created:\n{response.status}")
         return App.from_auth_helper(auth=self.auth_helper, app_id=app_id)
 
     def _process_compute_cluster_config(
@@ -255,7 +255,9 @@ class User(Lister, BaseClient):
         response = self._grpc_request(self.STUB.PostComputeClusters, request)
         if response.status.code != status_code_pb2.SUCCESS:
             raise Exception(response.status)
-        self.logger.info("\nCompute Cluster created\n%s", response.status)
+        self.logger.info(
+            f"Compute Cluster with ID '{compute_cluster_id}' is created:\n{response.status}"
+        )
         return ComputeCluster.from_auth_helper(
             auth=self.auth_helper, compute_cluster_id=compute_cluster_id
         )

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

@@ -133,7 +133,7 @@ def serve(
             pat=pat,
             num_parallel_polls=num_threads,
         )
-        logger.info("Runner started successfully and is waiting for work from the API...")
+        logger.info("Runner started successfully and is waiting for work from the API...\n")
         runner.start()  # start the runner to fetch work from the API.
 
 

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

@@ -220,3 +220,130 @@ def validate_context_auth(pat: str, user_id: str, api_base: str = None):
             logger.error(f"❌ Validation failed: \n{error_msg}")
             logger.error("Please check your credentials and try again.")
         raise click.Abort()  # Exit without saving the configuration
+
+
+def customize_ollama_model(model_path, model_name, port, context_length):
+    """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')
+
+    """
+    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}'"
+            )
+
+        # 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 check_requirements_installed(model_path):
+    """Check if all dependencies in requirements.txt are installed."""
+    import re
+    from pathlib import Path
+
+    requirements_path = Path(model_path) / "requirements.txt"
+
+    if not requirements_path.exists():
+        logger.warning(f"requirements.txt not found at {requirements_path}")
+        return True
+
+    try:
+        package_pattern = re.compile(r'^([a-zA-Z0-9_-]+)')
+
+        # Getting package name and version (for logging)
+        requirements = [
+            (match.group(1), pack)
+            for line in requirements_path.read_text().splitlines()
+            if (pack := line.strip())
+            and not line.startswith('#')
+            and (match := package_pattern.match(line))
+        ]
+
+        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
+            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))
+        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.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clarifai
-Version: 11.6.4rc2
+Version: 11.6.5
 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.4
 Requires-Dist: clarifai-protocol>=0.0.25
 Requires-Dist: numpy>=1.22.0
 Requires-Dist: tqdm>=4.65.0