clarifai 10.5.0__py3-none-any.whl → 10.5.1__py3-none-any.whl

clarifai/client/app.py

@@ -30,6 +30,7 @@ class App(Lister, BaseClient):
   def __init__(self,
                url: str = None,
                app_id: str = None,
+               user_id: str = None,
                base_url: str = "https://api.clarifai.com",
                pat: str = None,
                token: str = None,
@@ -53,6 +54,9 @@ class App(Lister, BaseClient):
     if url:
       user_id, app_id = ClarifaiUrlHelper.split_clarifai_app_url(url)
       kwargs = {'user_id': user_id}
+    if user_id:
+      kwargs = {'user_id': user_id}
+
     self.kwargs = {**kwargs, 'id': app_id}
     self.app_info = resources_pb2.App(**self.kwargs)
     self.logger = get_logger(logger_level="INFO", name=__name__)

clarifai/client/auth/helper.py

@@ -105,9 +105,6 @@ class ClarifaiAuthHelper:
     if self.user_id == "":
       raise Exception(
           "Need 'user_id' to not be empty in the query params or user CLARIFAI_USER_ID env var")
-    if self.app_id == "":
-      raise Exception(
-          "Need 'app_id' to not be empty in the query params or user CLARIFAI_APP_ID env var")
     if self._pat != "" and self._token != "":
       raise Exception(
           "A personal access token OR a session token need to be provided, but you cannot provide both."

clarifai/client/auth/stub.py

@@ -1,3 +1,4 @@
+import itertools
 import logging
 import time
 from concurrent.futures import ThreadPoolExecutor
@@ -20,6 +21,34 @@ retry_codes_grpc = {
 _threadpool = ThreadPoolExecutor(100)
 
 
+def validate_response(response, attempt, max_attempts):
+  # Helper function to handle simple response validation
+  def handle_simple_response(response):
+    if hasattr(response, 'status') and hasattr(response.status, 'code'):
+      if (response.status.code in throttle_status_codes) and attempt < max_attempts:
+        logging.debug('Retrying with status %s' % str(response.status))
+        return None  # Indicates a retry is needed
+      else:
+        return response
+
+  # Check if the response is an instance of a gRPC streaming call
+  if isinstance(response, grpc._channel._MultiThreadedRendezvous):
+    try:
+      # Check just the first response in the stream for validation
+      first_res = next(response)
+      validated_response = handle_simple_response(first_res)
+      if validated_response is not None:
+        # Have to return that first response and the rest of the stream.
+        return itertools.chain([validated_response], response)
+      return None  # Indicates a retry is needed
+    except grpc.RpcError as e:
+      logging.error('Error processing streaming response: %s' % str(e))
+      return None  # Indicates an error
+  else:
+    # Handle simple response validation
+    return handle_simple_response(response)
+
+
 def create_stub(auth_helper: ClarifaiAuthHelper = None, max_retry_attempts: int = 10) -> V2Stub:
   """
   Create client stub that handles authorization and basic retries for
@@ -109,10 +138,9 @@ class _RetryRpcCallable(RpcCallable):
         time.sleep(self.backoff_time)  # TODO better backoff between attempts
       try:
         response = self.f(*args, **kwargs)
-        if (response.status.code in throttle_status_codes) and attempt < self.max_attempts:
-          logging.debug('Retrying with status %s' % str(response.status))
-        else:
-          return response
+        v = validate_response(response, attempt, self.max_attempts)
+        if v is not None:
+          return v
       except grpc.RpcError as e:
         if (e.code() in retry_codes_grpc) and attempt < self.max_attempts:
           logging.debug('Retrying with status %s' % e.code())

clarifai/client/base.py

@@ -8,6 +8,7 @@ from google.protobuf.wrappers_pb2 import BoolValue
 from clarifai.client.auth import create_stub
 from clarifai.client.auth.helper import ClarifaiAuthHelper
 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
 
 
@@ -36,9 +37,9 @@ class BaseClient:
   def __init__(self, **kwargs):
     token, pat = "", ""
     try:
-      pat = get_from_dict_or_env(key="pat", env_key="CLARIFAI_PAT", **kwargs)
+      pat = get_from_dict_or_env(key="pat", env_key=CLARIFAI_PAT_ENV_VAR, **kwargs)
     except UserError:
-      token = get_from_dict_or_env(key="token", env_key="CLARIFAI_SESSION_TOKEN", **kwargs)
+      token = get_from_dict_or_env(key="token", env_key=CLARIFAI_SESSION_TOKEN_ENV_VAR, **kwargs)
     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"
@@ -54,6 +55,11 @@ class BaseClient:
     self.base = self.auth_helper.base
     self.root_certificates_path = self.auth_helper._root_certificates_path
 
+  @classmethod
+  def from_env(cls, validate: bool = False):
+    auth = ClarifaiAuthHelper.from_env(validate=validate)
+    return cls.from_auth_helper(auth)
+
   @classmethod
   def from_auth_helper(cls, auth: ClarifaiAuthHelper, **kwargs):
     default_kwargs = {

clarifai/client/model.py

@@ -1,7 +1,7 @@
 import json
 import os
 import time
-from typing import Any, Dict, Generator, List, Tuple, Union
+from typing import Any, Dict, Generator, Iterator, List, Tuple, Union
 
 import numpy as np
 import requests
@@ -553,6 +553,315 @@ class Model(Lister, BaseClient):
     return self.predict(
         inputs=[input_proto], inference_params=inference_params, output_config=output_config)
 
+  def generate(self, inputs: List[Input], inference_params: Dict = {}, output_config: Dict = {}):
+    """Generate the stream output on model based on the given inputs.
+
+    Args:
+        inputs (list[Input]): The inputs to predict, must be less than 128.
+    """
+    if not isinstance(inputs, list):
+      raise UserError('Invalid inputs, inputs must be a list of Input objects.')
+    if len(inputs) > MAX_MODEL_PREDICT_INPUTS:
+      raise UserError(f"Too many inputs. Max is {MAX_MODEL_PREDICT_INPUTS}."
+                     )  # TODO Use Chunker for inputs len > 128
+
+    self._override_model_version(inference_params, output_config)
+    request = service_pb2.PostModelOutputsRequest(
+        user_app_id=self.user_app_id,
+        model_id=self.id,
+        version_id=self.model_version.id,
+        inputs=inputs,
+        model=self.model_info)
+
+    start_time = time.time()
+    backoff_iterator = BackoffIterator(10)
+    generation_started = False
+    while True:
+      if generation_started:
+        break
+      stream_response = self._grpc_request(self.STUB.GenerateModelOutputs, request)
+      for response in stream_response:
+        if response.status.code == status_code_pb2.MODEL_DEPLOYING and \
+                time.time() - start_time < 60 * 10:
+          self.logger.info(f"{self.id} model is still deploying, please wait...")
+          time.sleep(next(backoff_iterator))
+          break
+        if response.status.code != status_code_pb2.SUCCESS:
+          raise Exception(f"Model Predict failed with response {response.status!r}")
+        else:
+          if not generation_started:
+            generation_started = True
+          yield response
+
+  def generate_by_filepath(self,
+                           filepath: str,
+                           input_type: str,
+                           inference_params: Dict = {},
+                           output_config: Dict = {}):
+    """Generate the stream output on model based on the given filepath.
+
+    Args:
+        filepath (str): The filepath to predict.
+        input_type (str): The type of input. Can be 'image', 'text', 'video' or 'audio.
+        inference_params (dict): The inference params to override.
+        output_config (dict): The output config to override.
+          min_value (float): The minimum value of the prediction confidence to filter.
+          max_concepts (int): The maximum number of concepts to return.
+          select_concepts (list[Concept]): The concepts to select.
+
+    Example:
+        >>> from clarifai.client.model import Model
+        >>> model = Model("url") # Example URL: https://clarifai.com/clarifai/main/models/general-image-recognition
+                    or
+        >>> model = Model(model_id='model_id', user_id='user_id', app_id='app_id')
+        >>> stream_response = model.generate_by_filepath('/path/to/image.jpg', 'image')
+        >>> stream_response = model.generate_by_filepath('/path/to/text.txt', 'text')
+        >>> list_stream_response = [response for response in stream_response]
+    """
+    if not os.path.isfile(filepath):
+      raise UserError('Invalid filepath.')
+
+    with open(filepath, "rb") as f:
+      file_bytes = f.read()
+
+    return self.generate_by_bytes(file_bytes, input_type, inference_params, output_config)
+
+  def generate_by_bytes(self,
+                        input_bytes: bytes,
+                        input_type: str,
+                        inference_params: Dict = {},
+                        output_config: Dict = {}):
+    """Generate the stream output on model based on the given bytes.
+
+    Args:
+        input_bytes (bytes): File Bytes to predict on.
+        input_type (str): The type of input. Can be 'image', 'text', 'video' or 'audio.
+        inference_params (dict): The inference params to override.
+        output_config (dict): The output config to override.
+          min_value (float): The minimum value of the prediction confidence to filter.
+          max_concepts (int): The maximum number of concepts to return.
+          select_concepts (list[Concept]): The concepts to select.
+
+    Example:
+        >>> from clarifai.client.model import Model
+        >>> model = Model("https://clarifai.com/openai/chat-completion/models/GPT-4")
+        >>> stream_response = model.generate_by_bytes(b'Write a tweet on future of AI',
+                                                      input_type='text',
+                                                      inference_params=dict(temperature=str(0.7), max_tokens=30)))
+        >>> list_stream_response = [response for response in stream_response]
+    """
+    if input_type not in {'image', 'text', 'video', 'audio'}:
+      raise UserError(
+          f"Got input type {input_type} but expected one of image, text, video, audio.")
+    if not isinstance(input_bytes, bytes):
+      raise UserError('Invalid bytes.')
+
+    if input_type == "image":
+      input_proto = Inputs.get_input_from_bytes("", image_bytes=input_bytes)
+    elif input_type == "text":
+      input_proto = Inputs.get_input_from_bytes("", text_bytes=input_bytes)
+    elif input_type == "video":
+      input_proto = Inputs.get_input_from_bytes("", video_bytes=input_bytes)
+    elif input_type == "audio":
+      input_proto = Inputs.get_input_from_bytes("", audio_bytes=input_bytes)
+
+    return self.generate(
+        inputs=[input_proto], inference_params=inference_params, output_config=output_config)
+
+  def generate_by_url(self,
+                      url: str,
+                      input_type: str,
+                      inference_params: Dict = {},
+                      output_config: Dict = {}):
+    """Generate the stream output on model based on the given URL.
+
+    Args:
+        url (str): The URL to predict.
+        input_type (str): The type of input. Can be 'image', 'text', 'video' or 'audio.
+        inference_params (dict): The inference params to override.
+        output_config (dict): The output config to override.
+          min_value (float): The minimum value of the prediction confidence to filter.
+          max_concepts (int): The maximum number of concepts to return.
+          select_concepts (list[Concept]): The concepts to select.
+
+    Example:
+        >>> from clarifai.client.model import Model
+        >>> model = Model("url") # Example URL: https://clarifai.com/clarifai/main/models/general-image-recognition
+                    or
+        >>> model = Model(model_id='model_id', user_id='user_id', app_id='app_id')
+        >>> stream_response = model.generate_by_url('url', 'image')
+        >>> list_stream_response = [response for response in stream_response]
+    """
+    if input_type not in {'image', 'text', 'video', 'audio'}:
+      raise UserError(
+          f"Got input type {input_type} but expected one of image, text, video, audio.")
+
+    if input_type == "image":
+      input_proto = Inputs.get_input_from_url("", image_url=url)
+    elif input_type == "text":
+      input_proto = Inputs.get_input_from_url("", text_url=url)
+    elif input_type == "video":
+      input_proto = Inputs.get_input_from_url("", video_url=url)
+    elif input_type == "audio":
+      input_proto = Inputs.get_input_from_url("", audio_url=url)
+
+    return self.generate(
+        inputs=[input_proto], inference_params=inference_params, output_config=output_config)
+
+  def _req_iterator(self, input_iterator: Iterator[List[Input]]):
+    for inputs in input_iterator:
+      yield service_pb2.PostModelOutputsRequest(
+          user_app_id=self.user_app_id,
+          model_id=self.id,
+          version_id=self.model_version.id,
+          inputs=inputs,
+          model=self.model_info)
+
+  def stream(self,
+             inputs: Iterator[List[Input]],
+             inference_params: Dict = {},
+             output_config: Dict = {}):
+    """Generate the stream output on model based on the given stream of inputs.
+
+    Args:
+        inputs (Iterator[list[Input]]): stream of inputs to predict, must be less than 128.
+    """
+    # if not isinstance(inputs, Iterator[List[Input]]):
+    #   raise UserError('Invalid inputs, inputs must be a iterator of list of Input objects.')
+
+    self._override_model_version(inference_params, output_config)
+    request = self._req_iterator(inputs)
+
+    start_time = time.time()
+    backoff_iterator = BackoffIterator(10)
+    generation_started = False
+    while True:
+      if generation_started:
+        break
+      stream_response = self._grpc_request(self.STUB.StreamModelOutputs, request)
+      for response in stream_response:
+        if response.status.code == status_code_pb2.MODEL_DEPLOYING and \
+                time.time() - start_time < 60 * 10:
+          self.logger.info(f"{self.id} model is still deploying, please wait...")
+          time.sleep(next(backoff_iterator))
+          break
+        if response.status.code != status_code_pb2.SUCCESS:
+          raise Exception(f"Model Predict failed with response {response.status!r}")
+        else:
+          if not generation_started:
+            generation_started = True
+          yield response
+
+  def stream_by_filepath(self,
+                         filepath: str,
+                         input_type: str,
+                         inference_params: Dict = {},
+                         output_config: Dict = {}):
+    """Stream the model output based on the given filepath.
+
+    Args:
+        filepath (str): The filepath to predict.
+        input_type (str): The type of input. Can be 'image', 'text', 'video' or 'audio.
+        inference_params (dict): The inference params to override.
+        output_config (dict): The output config to override.
+          min_value (float): The minimum value of the prediction confidence to filter.
+          max_concepts (int): The maximum number of concepts to return.
+          select_concepts (list[Concept]): The concepts to select.
+
+    Example:
+        >>> from clarifai.client.model import Model
+        >>> model = Model("url")
+        >>> stream_response = model.stream_by_filepath('/path/to/image.jpg', 'image')
+        >>> list_stream_response = [response for response in stream_response]
+    """
+    if not os.path.isfile(filepath):
+      raise UserError('Invalid filepath.')
+
+    with open(filepath, "rb") as f:
+      file_bytes = f.read()
+
+    return self.stream_by_bytes(iter([file_bytes]), input_type, inference_params, output_config)
+
+  def stream_by_bytes(self,
+                      input_bytes_iterator: Iterator[bytes],
+                      input_type: str,
+                      inference_params: Dict = {},
+                      output_config: Dict = {}):
+    """Stream the model output based on the given bytes.
+
+    Args:
+        input_bytes_iterator (Iterator[bytes]): Iterator of file bytes to predict on.
+        input_type (str): The type of input. Can be 'image', 'text', 'video' or 'audio.
+        inference_params (dict): The inference params to override.
+        output_config (dict): The output config to override.
+          min_value (float): The minimum value of the prediction confidence to filter.
+          max_concepts (int): The maximum number of concepts to return.
+          select_concepts (list[Concept]): The concepts to select.
+
+    Example:
+        >>> from clarifai.client.model import Model
+        >>> model = Model("https://clarifai.com/openai/chat-completion/models/GPT-4")
+        >>> stream_response = model.stream_by_bytes(iter([b'Write a tweet on future of AI']),
+                                                    input_type='text',
+                                                    inference_params=dict(temperature=str(0.7), max_tokens=30)))
+        >>> list_stream_response = [response for response in stream_response]
+    """
+    if input_type not in {'image', 'text', 'video', 'audio'}:
+      raise UserError(
+          f"Got input type {input_type} but expected one of image, text, video, audio.")
+
+    def input_generator():
+      for input_bytes in input_bytes_iterator:
+        if input_type == "image":
+          yield [Inputs.get_input_from_bytes("", image_bytes=input_bytes)]
+        elif input_type == "text":
+          yield [Inputs.get_input_from_bytes("", text_bytes=input_bytes)]
+        elif input_type == "video":
+          yield [Inputs.get_input_from_bytes("", video_bytes=input_bytes)]
+        elif input_type == "audio":
+          yield [Inputs.get_input_from_bytes("", audio_bytes=input_bytes)]
+
+    return self.stream(input_generator(), inference_params, output_config)
+
+  def stream_by_url(self,
+                    url_iterator: Iterator[str],
+                    input_type: str,
+                    inference_params: Dict = {},
+                    output_config: Dict = {}):
+    """Stream the model output based on the given URL.
+
+    Args:
+        url_iterator (Iterator[str]): Iterator of URLs to predict.
+        input_type (str): The type of input. Can be 'image', 'text', 'video' or 'audio.
+        inference_params (dict): The inference params to override.
+        output_config (dict): The output config to override.
+          min_value (float): The minimum value of the prediction confidence to filter.
+          max_concepts (int): The maximum number of concepts to return.
+          select_concepts (list[Concept]): The concepts to select.
+
+    Example:
+        >>> from clarifai.client.model import Model
+        >>> model = Model("url")
+        >>> stream_response = model.stream_by_url(iter(['url']), 'image')
+        >>> list_stream_response = [response for response in stream_response]
+    """
+    if input_type not in {'image', 'text', 'video', 'audio'}:
+      raise UserError(
+          f"Got input type {input_type} but expected one of image, text, video, audio.")
+
+    def input_generator():
+      for url in url_iterator:
+        if input_type == "image":
+          yield [Inputs.get_input_from_url("", image_url=url)]
+        elif input_type == "text":
+          yield [Inputs.get_input_from_url("", text_url=url)]
+        elif input_type == "video":
+          yield [Inputs.get_input_from_url("", video_url=url)]
+        elif input_type == "audio":
+          yield [Inputs.get_input_from_url("", audio_url=url)]
+
+    return self.stream(input_generator(), inference_params, output_config)
+
   def _override_model_version(self, inference_params: Dict = {}, output_config: Dict = {}) -> None:
     """Overrides the model version.
 

clarifai/models/model_serving/cli/login.py

@@ -1,6 +1,6 @@
 import argparse
 
-from ..constants import CLARIFAI_PAT_PATH
+from clarifai.utils.constants import CLARIFAI_PAT_PATH
 from ..utils import _persist_pat
 from .base import BaseClarifaiCli
 

clarifai/models/model_serving/cli/upload.py

@@ -97,11 +97,15 @@ class UploadModelSubCli(BaseClarifaiCli):
     self.file = args.file
     self.url = args.url
     if self.file:
-      assert self.url, ValueError("Provide either file or url, but got both.")
+      assert not self.url, ValueError("Expected either file or url, not both.")
       assert os.path.exists(self.file), FileNotFoundError
     elif self.url:
-      assert self.url.startswith("http") or self.url.startswith(
-          "s3"), f"Invalid url supported http or s3 url. Got {self.url}"
+      if len(self.url.split(":")) == 1:
+        # if URL has no scheme, default to https
+        self.url = f"https://{self.url}"
+      assert self.url.startswith("http") or self.url.startswith("https") or self.url.startswith(
+          "s3"
+      ), f"Invalid URL scheme, supported schemes are 'http', 'https', or 's3'. Got {self.url}"
       self.file = None
     else:
       for _fname in os.listdir(working_dir_or_config):

clarifai/models/model_serving/constants.py

@@ -1,20 +1,13 @@
 import os
 
+from clarifai.utils.constants import CLARIFAI_HOME
+
 MAX_HW_DIM = 1024
 IMAGE_TENSOR_NAME = "image"
 TEXT_TENSOR_NAME = "text"
 
 BUILT_MODEL_EXT = ".clarifai"
 
-default_home = os.path.join(os.path.expanduser("~"), ".cache")
-CLARIFAI_HOME = os.path.expanduser(
-    os.getenv(
-        "CLARIFAI_HOME",
-        os.path.join(os.getenv("XDG_CACHE_HOME", default_home), "clarifai"),
-    ))
-os.makedirs(CLARIFAI_HOME, exist_ok=True)
-CLARIFAI_PAT_PATH = os.path.join(CLARIFAI_HOME, "pat")
-
 CLARIFAI_EXAMPLES_REPO = "https://github.com/Clarifai/examples.git"
 repo_name = CLARIFAI_EXAMPLES_REPO.split("/")[-1].replace(".git", "")
 CLARIFAI_EXAMPLES_REPO_PATH = os.path.join(CLARIFAI_HOME, repo_name)

clarifai/models/model_serving/utils.py

@@ -1,6 +1,6 @@
 import os
 
-from .constants import CLARIFAI_PAT_PATH
+from clarifai.utils.constants import CLARIFAI_PAT_ENV_VAR, CLARIFAI_PAT_PATH
 
 
 def _persist_pat(pat: str):
@@ -10,10 +10,17 @@ def _persist_pat(pat: str):
 
 
 def _read_pat():
-  if not os.path.exists(CLARIFAI_PAT_PATH):
+  if not os.path.exists(CLARIFAI_PAT_PATH) and not os.environ.get(CLARIFAI_PAT_ENV_VAR, ""):
     return None
-  with open(CLARIFAI_PAT_PATH, "r") as f:
-    return f.read().replace("\n", "").replace("\r", "").strip()
+  if os.path.exists(CLARIFAI_PAT_PATH):
+    with open(CLARIFAI_PAT_PATH, "r") as f:
+      return f.read().replace("\n", "").replace("\r", "").strip()
+  elif os.environ.get(CLARIFAI_PAT_ENV_VAR):
+    return os.environ.get(CLARIFAI_PAT_ENV_VAR)
+  else:
+    raise ValueError(
+        f"PAT not found, please run `clarifai login` to persist your PAT or set it as an environment variable under the name '{CLARIFAI_PAT_ENV_VAR}'"
+    )
 
 
 def login(pat=None):

clarifai/utils/constants.py

@@ -0,0 +1,12 @@
+import os
+
+USER_CACHE_DIR = os.path.join(os.path.expanduser("~"), ".cache")
+CLARIFAI_HOME = os.path.expanduser(
+    os.getenv(
+        "CLARIFAI_HOME",
+        os.path.join(os.getenv("XDG_CACHE_HOME", USER_CACHE_DIR), "clarifai"),
+    ))
+os.makedirs(CLARIFAI_HOME, exist_ok=True)
+CLARIFAI_PAT_PATH = os.path.join(CLARIFAI_HOME, "pat")
+CLARIFAI_PAT_ENV_VAR = "CLARIFAI_PAT"
+CLARIFAI_SESSION_TOKEN_ENV_VAR = "CLARIFAI_SESSION_TOKEN"

clarifai/versions.py

@@ -1,6 +1,6 @@
 import os
 
-CLIENT_VERSION = "10.5.0"
+CLIENT_VERSION = "10.5.1"
 OS_VER = os.sys.platform
 PYTHON_VERSION = '.'.join(
     map(str, [os.sys.version_info.major, os.sys.version_info.minor, os.sys.version_info.micro]))

{clarifai-10.5.0.dist-info → clarifai-10.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: clarifai
-Version: 10.5.0
+Version: 10.5.1
 Summary: Clarifai Python SDK
 Home-page: https://github.com/Clarifai/clarifai-python
 Author: Clarifai

{clarifai-10.5.0.dist-info → clarifai-10.5.1.dist-info}/RECORD

@@ -1,22 +1,22 @@
 clarifai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 clarifai/cli.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 clarifai/errors.py,sha256=RwzTajwds51wLD0MVlMC5kcpBnzRpreDLlazPSBZxrg,2605
-clarifai/versions.py,sha256=45yN_CYVHYMj9_5f2wK7IgHdCYaA5KHH9NBdC2-5rj0,186
+clarifai/versions.py,sha256=tIgKRwGSVz7SowiYM6ZS42kkJr2EJxVJ-4slCa28Dt0,186
 clarifai/client/__init__.py,sha256=xI1U0l5AZdRThvQAXCLsd9axxyFzXXJ22m8LHqVjQRU,662
-clarifai/client/app.py,sha256=LC3rnuqr97f-S7LsJ9Q7KZnYMBHGDAq4mcFjjcPjpqo,27240
-clarifai/client/base.py,sha256=FrnSY9tSxjTxhABfBzQz5-PEppWMPbIyvSNnx8mVz8s,6919
+clarifai/client/app.py,sha256=br3C2paGmWzKu4eG0kUN1m8kDPKqpGPq28f7Xiy2v54,27329
+clarifai/client/base.py,sha256=wStnn_gS6sYo36OlYRzEkOFShXOQg3DKUp8i6DomAxQ,7178
 clarifai/client/dataset.py,sha256=XX-J-9Ict1CQrEycq-JbdxUTuucSgLeDSvnlHE1ucQY,29903
 clarifai/client/input.py,sha256=Av_gPrmwa1vorDs5Pz9jUbY1MwXHYFb3NyF_a1S1aII,41630
 clarifai/client/lister.py,sha256=03KGMvs5RVyYqxLsSrWhNc34I8kiF1Ph0NeyEwu7nMU,2082
-clarifai/client/model.py,sha256=QTVSeR3D3SHh8rK6kWHATy87qS8khYeXIKbs9dn5W4I,58487
+clarifai/client/model.py,sha256=Q0XEOWaZvSFPx7cLp4xJcwV5SVD1iU_6-DdDJmF-Hfk,72623
 clarifai/client/module.py,sha256=360JaOasX0DZCNE_Trj0LNTr-T_tUDZLfGpz0CdIi78,4248
 clarifai/client/search.py,sha256=iwZqwuEodbjIOEPMIjpic8caFGg3u51RK816pr-574o,14964
 clarifai/client/user.py,sha256=EQTeotfYTNedGcbTICYOUJqKgWhfVHvaMRTJ1hdoIdQ,10372
 clarifai/client/workflow.py,sha256=e3axkhU6c6WcxK9P5tgmnV464k-afslSzsSXx6nSMgA,10560
 clarifai/client/auth/__init__.py,sha256=7EwR0NrozkAUwpUnCsqXvE_p0wqx_SelXlSpKShKJK0,136
-clarifai/client/auth/helper.py,sha256=Wa5gkX0dl0xBwrT0E10lv9_Eoeh-WrMZR0Qc0YcV7es,14225
+clarifai/client/auth/helper.py,sha256=5aH2OjiWyuJk2K-1mfvXaD_OxEC014JEilUCpTwzCuY,14081
 clarifai/client/auth/register.py,sha256=2CMdBsoVLoTfjyksE6j7BM2tiEc73WKYvxnwDDgNn1k,536
-clarifai/client/auth/stub.py,sha256=KIzJZ8aRB1RzXJeWHDAx19HNdBsblPPHwYLfAkgI3rY,3779
+clarifai/client/auth/stub.py,sha256=xy4-fV0W8keCgXld4eOVzFQEIKxOktNwtL5bLztReug,4940
 clarifai/constants/dataset.py,sha256=OXYirr0iaoN_47V6wxO0H6ptV81y8zNGapPBz9qqD8o,516
 clarifai/constants/input.py,sha256=WcHwToUVIK9ItAhDefaSohQHCLNeR55PSjZ0BFnoZ3U,28
 clarifai/constants/model.py,sha256=oTad43ncskVHfQ9vEbL2yy0Fac666dXr7QuO8zZXHAE,245
@@ -42,8 +42,8 @@ clarifai/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 clarifai/models/api.py,sha256=d3FQQlG0mNDLrfEvchqaVcq4Tgb_TqryNnJtwp3c7sE,10961
 clarifai/models/model_serving/README.md,sha256=zXnKybVoIF_LYHKKY2vijTCaGcb2-GJ5kef2uB1WFrs,4241
 clarifai/models/model_serving/__init__.py,sha256=78fiK9LvdGvpMxICmZWqSIyS6BFATjW2s5R6_GgtbPA,645
-clarifai/models/model_serving/constants.py,sha256=uoi8TqEFkdsHhSZu90HOO3R0BmPC3G0z9qA5ER-5H7w,688
-clarifai/models/model_serving/utils.py,sha256=D2UZo90Afd9f7OGKXdjRqys_6N26psY018V7R-rcNO4,629
+clarifai/models/model_serving/constants.py,sha256=VeSkzXijU9E0axBUbGs4pQG9V7lA-G8bYVVfxrPgB9U,419
+clarifai/models/model_serving/utils.py,sha256=zbFKpQ3Xom-zvNP9bqobIxXFdlCbxBRuGr7RFlg334Y,1038
 clarifai/models/model_serving/cli/__init__.py,sha256=Nls28G-fedNw2oQZIkPQSN__TgjJXbG9RDzzuHIM0VI,575
 clarifai/models/model_serving/cli/_utils.py,sha256=CZTKKiaoO1Mg5MKQS2Qhgy4JRjnkEHqy8zY5U6b6C0w,1734
 clarifai/models/model_serving/cli/base.py,sha256=k4ARNU1koNzGAi9ach6Vpk7hpISZySiYHyKjkBLuHLg,283
@@ -51,8 +51,8 @@ clarifai/models/model_serving/cli/build.py,sha256=-C4PBt-9xO9YsyUagz3kF4J0_PsYb6
 clarifai/models/model_serving/cli/clarifai_clis.py,sha256=sGDDj7MrlU3goWLQm4H9dCf4lPD2Ojx50_jdIoxb5QM,663
 clarifai/models/model_serving/cli/create.py,sha256=wtKcVi8XSPN-Fx0RrSUxEwH1hm5TbZ_FrCEMIS9yszM,5598
 clarifai/models/model_serving/cli/example_cli.py,sha256=tCm0J4EI0kuuSRhEiPTuraSA-bUYwtEFEHcL1eOXzRI,1039
-clarifai/models/model_serving/cli/login.py,sha256=TYRQALJZUhNvtx2VcChO0y41YXs8-yP9BrShYb9tcOM,743
-clarifai/models/model_serving/cli/upload.py,sha256=aLq5Fjc2av0-MRnE6lSWmBYxvm5yseIekWLHGXAhsb8,6813
+clarifai/models/model_serving/cli/login.py,sha256=yNHedXKqqw_fxECaEDrWKPLCvOgGdHjNQv3MuRZpMSg,756
+clarifai/models/model_serving/cli/upload.py,sha256=kOz8OOEobo6sLUkS1xg0672PTmMkx0aWxjKMhSRlMwM,7013
 clarifai/models/model_serving/docs/cli.md,sha256=fLgyY8sYMPjYQW_q8Q9yJYB_ryDVGbzj2VouJgvkEFw,4564
 clarifai/models/model_serving/docs/concepts.md,sha256=ppQADibKQInf9JpfcH7wIpcMndTZ3618or5yzMhGNOE,9376
 clarifai/models/model_serving/docs/dependencies.md,sha256=apwg_IxDBzovtQYXRpWMU9pUqdf0VaS10yMVOYYXhoc,728
@@ -95,6 +95,7 @@ clarifai/rag/utils.py,sha256=yr1jAcbpws4vFGBqlAwPPE7v1DRba48g8gixLFw8OhQ,4070
 clarifai/schema/search.py,sha256=JjTi8ammJgZZ2OGl4K6tIA4zEJ1Fr2ASZARXavI1j5c,2448
 clarifai/urls/helper.py,sha256=tjoMGGHuWX68DUB0pk4MEjrmFsClUAQj2jmVEM_Sy78,4751
 clarifai/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+clarifai/utils/constants.py,sha256=SJ6FzfvtA2Pe3QxKtNnnxxAbvetbh7v3wGCTXip7z_0,431
 clarifai/utils/logging.py,sha256=xJTteoUodQ7RfsbO676QgidKa5EVPbdUu89Xlwwso2s,4533
 clarifai/utils/misc.py,sha256=GznzquXXFt8J9qzMWtTJPFWCSc5QTs_ZBldW1mXCZzE,1285
 clarifai/utils/model_train.py,sha256=Mndqy5GNu7kjQHjDyNVyamL0hQFLGSHcWhOuPyOvr1w,8005
@@ -106,9 +107,9 @@ clarifai/workflows/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuF
 clarifai/workflows/export.py,sha256=vICRhIreqDSShxLKjHNM2JwzKsf1B4fdXB0ciMcA70k,1945
 clarifai/workflows/utils.py,sha256=nGeB_yjVgUO9kOeKTg4OBBaBz-AwXI3m-huSVj-9W18,1924
 clarifai/workflows/validate.py,sha256=yJq03MaJqi5AK3alKGJJBR89xmmjAQ31sVufJUiOqY8,2556
-clarifai-10.5.0.dist-info/LICENSE,sha256=mUqF_d12-qE2n41g7C5_sq-BMLOcj6CNN-jevr15YHU,555
-clarifai-10.5.0.dist-info/METADATA,sha256=XR2mF-8uqgbOp-nJXh97xrzITiszzpnq0D7xffqUryM,19372
-clarifai-10.5.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-clarifai-10.5.0.dist-info/entry_points.txt,sha256=qZOr_MIPG0dBBE1zringDJS_wXNGTAA_SQ-zcbmDHOw,82
-clarifai-10.5.0.dist-info/top_level.txt,sha256=wUMdCQGjkxaynZ6nZ9FAnvBUCgp5RJUVFSy2j-KYo0s,9
-clarifai-10.5.0.dist-info/RECORD,,
+clarifai-10.5.1.dist-info/LICENSE,sha256=mUqF_d12-qE2n41g7C5_sq-BMLOcj6CNN-jevr15YHU,555
+clarifai-10.5.1.dist-info/METADATA,sha256=f1Ga6-33hEMjW56xOUGAeZIELIEJx_m6HOYj2p9ni78,19372
+clarifai-10.5.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+clarifai-10.5.1.dist-info/entry_points.txt,sha256=qZOr_MIPG0dBBE1zringDJS_wXNGTAA_SQ-zcbmDHOw,82
+clarifai-10.5.1.dist-info/top_level.txt,sha256=wUMdCQGjkxaynZ6nZ9FAnvBUCgp5RJUVFSy2j-KYo0s,9
+clarifai-10.5.1.dist-info/RECORD,,