clarifai 10.5.0__tar.gz → 10.5.1__tar.gz

{clarifai-10.5.0/clarifai.egg-info → clarifai-10.5.1}/PKG-INFO

@@ -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.1/VERSION

@@ -0,0 +1 @@
+10.5.1

{clarifai-10.5.0 → clarifai-10.5.1}/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-10.5.0 → clarifai-10.5.1}/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-10.5.0 → clarifai-10.5.1}/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-10.5.0 → clarifai-10.5.1}/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-10.5.0 → clarifai-10.5.1}/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-10.5.0 → clarifai-10.5.1}/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-10.5.0 → clarifai-10.5.1}/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-10.5.0 → clarifai-10.5.1}/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-10.5.1/clarifai/models/model_serving/utils.py

@@ -0,0 +1,30 @@
+import os
+
+from clarifai.utils.constants import CLARIFAI_PAT_ENV_VAR, CLARIFAI_PAT_PATH
+
+
+def _persist_pat(pat: str):
+  """ Write down pat to CLARIFAI_PAT_PATH """
+  with open(CLARIFAI_PAT_PATH, "w") as f:
+    f.write(pat)
+
+
+def _read_pat():
+  if not os.path.exists(CLARIFAI_PAT_PATH) and not os.environ.get(CLARIFAI_PAT_ENV_VAR, ""):
+    return None
+  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):
+  """ if pat provided, set pat to CLARIFAI_PAT otherwise read pat from file"""
+  pat = pat or _read_pat()
+  assert pat, Exception("PAT is not found, please run `clarifai login` to persist your PAT")
+  os.environ["CLARIFAI_PAT"] = pat

clarifai-10.5.1/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-10.5.0 → clarifai-10.5.1}/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 → clarifai-10.5.1/clarifai.egg-info}/PKG-INFO

@@ -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 → clarifai-10.5.1}/clarifai.egg-info/SOURCES.txt

@@ -108,6 +108,7 @@ clarifai/rag/utils.py
 clarifai/schema/search.py
 clarifai/urls/helper.py
 clarifai/utils/__init__.py
+clarifai/utils/constants.py
 clarifai/utils/logging.py
 clarifai/utils/misc.py
 clarifai/utils/model_train.py

{clarifai-10.5.0 → clarifai-10.5.1}/tests/test_auth.py

@@ -79,14 +79,6 @@ def test_exception_empty_user():
     ClarifaiAuthHelper("", "main", "fake_pat")
 
 
-def test_exception_empty_app():
-  ClarifaiAuthHelper("clarifai", "", "fake_pat", validate=False)
-  with pytest.raises(
-      Exception,
-      match="Need 'app_id' to not be empty in the query params or user CLARIFAI_APP_ID env var"):
-    ClarifaiAuthHelper("clarifai", "", "fake_pat")
-
-
 def test_exception_empty_pat():
   ClarifaiAuthHelper("clarifai", "main", "", validate=False)
   with pytest.raises(

{clarifai-10.5.0 → clarifai-10.5.1}/tests/test_search.py

@@ -1,6 +1,6 @@
 import os
-import time
 import typing
+import uuid
 
 import pytest
 from google.protobuf import struct_pb2
@@ -10,8 +10,8 @@ from clarifai.client.user import User
 from clarifai.errors import UserError
 
 CREATE_APP_USER_ID = os.environ["CLARIFAI_USER_ID"]
-now = int(time.time())
-CREATE_APP_ID = f"ci_search_app_{now}"
+uniq = uuid.uuid4().hex[:10]
+CREATE_APP_ID = f"ci_search_app_{uniq}"
 CREATE_DATASET_ID = "ci_search_dataset"
 DOG_IMG_URL = "https://samples.clarifai.com/dog.tiff"
 DATASET_IMAGES_DIR = os.path.dirname(__file__) + "/assets/voc/images"

clarifai-10.5.0/VERSION

@@ -1 +0,0 @@
-10.5.0

clarifai-10.5.0/clarifai/models/model_serving/utils.py

@@ -1,23 +0,0 @@
-import os
-
-from .constants import CLARIFAI_PAT_PATH
-
-
-def _persist_pat(pat: str):
-  """ Write down pat to CLARIFAI_PAT_PATH """
-  with open(CLARIFAI_PAT_PATH, "w") as f:
-    f.write(pat)
-
-
-def _read_pat():
-  if not os.path.exists(CLARIFAI_PAT_PATH):
-    return None
-  with open(CLARIFAI_PAT_PATH, "r") as f:
-    return f.read().replace("\n", "").replace("\r", "").strip()
-
-
-def login(pat=None):
-  """ if pat provided, set pat to CLARIFAI_PAT otherwise read pat from file"""
-  pat = pat or _read_pat()
-  assert pat, Exception("PAT is not found, please run `clarifai login` to persist your PAT")
-  os.environ["CLARIFAI_PAT"] = pat