clarifai 10.10.0__tar.gz → 10.11.0__tar.gz

{clarifai-10.10.0/clarifai.egg-info → clarifai-10.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: clarifai
-Version: 10.10.0
+Version: 10.11.0
 Summary: Clarifai Python SDK
 Home-page: https://github.com/Clarifai/clarifai-python
 Author: Clarifai
@@ -20,7 +20,7 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: clarifai-grpc>=10.9.11
+Requires-Dist: clarifai-grpc>=10.10.2
 Requires-Dist: clarifai-protocol>=0.0.6
 Requires-Dist: numpy>=1.22.0
 Requires-Dist: tqdm>=4.65.0

clarifai-10.11.0/clarifai/__init__.py

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

{clarifai-10.10.0 → clarifai-10.11.0}/clarifai/cli/model.py

@@ -39,11 +39,16 @@ def upload(model_path, download_checkpoints, skip_dockerfile):
     type=click.Path(exists=True),
     required=True,
     help='Path to the model directory.')
-def test_locally(model_path):
+@click.option(
+    '--keep_env',
+    is_flag=True,
+    help='Flag to keep the virtual environment after testing the model\
+    locally. Defaults to False, which will delete the virtual environment after testing.')
+def test_locally(model_path, keep_env=False):
   """Test model locally."""
   try:
     from clarifai.runners.models import model_run_locally
-    model_run_locally.main(model_path)
+    model_run_locally.main(model_path, keep_env=keep_env)
     click.echo(f"Model tested locally from {model_path}.")
   except Exception as e:
     click.echo(f"Failed to test model locally: {e}", err=True)

{clarifai-10.10.0 → clarifai-10.11.0}/clarifai/client/dataset.py

@@ -9,6 +9,7 @@ from typing import Dict, Generator, List, Optional, Tuple, Type, TypeVar, Union
 
 import requests
 from clarifai_grpc.grpc.api import resources_pb2, service_pb2
+from clarifai_grpc.grpc.api.resources_pb2 import Input
 from clarifai_grpc.grpc.api.service_pb2 import MultiInputResponse
 from clarifai_grpc.grpc.api.status import status_code_pb2, status_pb2
 from google.protobuf.json_format import MessageToDict
@@ -190,6 +191,26 @@ class Dataset(Lister, BaseClient):
       }
       yield Dataset.from_auth_helper(self.auth_helper, **kwargs)
 
+  def list_inputs(self, page_no: int = None, per_page: int = None,
+                  input_type: str = None) -> Generator[Input, None, None]:
+    """Lists all the inputs for the dataset.
+
+    Args:
+        page_no (int): The page number to list.
+        per_page (int): The number of items per page.
+        input_type (str): The type of input to list. Options: 'image', 'video', 'audio', 'text'.
+
+    Yields:
+        Input: Input objects in the dataset.
+
+    Example:
+        >>> from clarifai.client.dataset import Dataset
+        >>> dataset = Dataset(dataset_id='dataset_id', user_id='user_id', app_id='app_id')
+        >>> all_dataset_inputs = list(dataset.list_inputs())
+    """
+    return self.input_object.list_inputs(
+        dataset_id=self.id, page_no=page_no, per_page=per_page, input_type=input_type)
+
   def __iter__(self):
     return iter(DatasetExportReader(archive_url=self.archive_zip()))
 

{clarifai-10.10.0 → clarifai-10.11.0}/clarifai/client/deployment.py

@@ -49,7 +49,8 @@ class Deployment(Lister, BaseClient):
     Returns:
         resources_pb2.RunnerSelector: A RunnerSelector object for the given deployment_id.
     """
-    return resources_pb2.RunnerSelector(deployment_id=deployment_id, user_id=user_id)
+    return resources_pb2.RunnerSelector(
+        deployment=resources_pb2.Deployment(id=deployment_id, user_id=user_id))
 
   def __getattr__(self, name):
     return getattr(self.deployment_info, name)

{clarifai-10.10.0 → clarifai-10.11.0}/clarifai/client/input.py

@@ -867,6 +867,33 @@ class Inputs(Lister, BaseClient):
       raise Exception(response.status)
     self.logger.info("\nInputs Deleted\n%s", response.status)
 
+  def delete_annotations(self, input_ids: List[str], annotation_ids: List[str] = []) -> None:
+    """Delete list of annotations of input objects from the app.
+
+    Args:
+        input_ids (Input): List of input objects for which annotations to delete.
+        annotation_ids (List[str]): List of annotation ids to delete.
+
+    Example:
+        >>> from clarifai.client.user import User
+        >>> input_obj = User(user_id="user_id").app(app_id="app_id").inputs()
+        >>> input_obj.delete_annotations(input_ids=['input_id_1', 'input_id_2'])
+
+    Note:
+        'annotation_ids' are optional but if the are provided, the number and order in
+        'annotation_ids' and 'input_ids' should match
+    """
+    if not isinstance(input_ids, list):
+      raise UserError("input_ids must be a list of input ids")
+    if annotation_ids and len(input_ids) != len(annotation_ids):
+      raise UserError("Number of provided annotation_ids and input_ids should match.")
+    request = service_pb2.DeleteAnnotationsRequest(
+        user_app_id=self.user_app_id, ids=annotation_ids, input_ids=input_ids)
+    response = self._grpc_request(self.STUB.DeleteAnnotations, request)
+    if response.status.code != status_code_pb2.SUCCESS:
+      raise Exception(response.status)
+    self.logger.info("\nAnnotations Deleted\n%s", response.status)
+
   def download_inputs(self, inputs: List[Input]) -> List[bytes]:
     """Download list of input objects from the app.
 

{clarifai-10.10.0 → clarifai-10.11.0}/clarifai/client/model.py

@@ -743,7 +743,7 @@ class Model(Lister, BaseClient):
       file_bytes = f.read()
 
     return self.generate_by_bytes(
-        filepath=file_bytes,
+        input_bytes=file_bytes,
         input_type=input_type,
         compute_cluster_id=compute_cluster_id,
         nodepool_id=nodepool_id,

{clarifai-10.10.0 → clarifai-10.11.0}/clarifai/datasets/export/inputs_annotations.py

@@ -165,6 +165,14 @@ class InputAnnotationDownloader:
   def _save_annotation_to_archive(self, new_archive: zipfile.ZipFile, annot_data: List[Dict],
                                   file_name: str) -> None:
     """Gets the annotation response bytestring (from requests) and append to zip file."""
+    # Fill zero values for missing bounding box keys
+    for annot in annot_data:
+      if annot.get('regionInfo') and annot['regionInfo'].get('boundingBox'):
+        bbox = annot['regionInfo']['boundingBox']
+        bbox.setdefault('topRow', 0)
+        bbox.setdefault('leftCol', 0)
+        bbox.setdefault('bottomRow', 0)
+        bbox.setdefault('rightCol', 0)
     # Serialize the dictionary to a JSON string
     json_str = json.dumps(annot_data)
     # Convert the JSON string to bytes

{clarifai-10.10.0 → clarifai-10.11.0}/clarifai/datasets/upload/multimodal.py

@@ -6,7 +6,6 @@ from google.protobuf.struct_pb2 import Struct
 
 from clarifai.client.input import Inputs
 from clarifai.datasets.upload.base import ClarifaiDataLoader, ClarifaiDataset
-from clarifai.utils.misc import get_uuid
 
 
 class MultiModalDataset(ClarifaiDataset):
@@ -36,7 +35,6 @@ class MultiModalDataset(ClarifaiDataset):
       image_bytes = data_item.image_bytes
       text = data_item.text
       labels = data_item.labels if isinstance(data_item.labels, list) else [data_item.labels]
-      id = get_uuid(8)
       input_id = f"{self.dataset_id}-{id}" if data_item.id is None else f"{self.dataset_id}-{str(data_item.id)}"
       if data_item.metadata is not None:
         metadata.update(data_item.metadata)

clarifai-10.10.0/clarifai/runners/dockerfile_template/Dockerfile.cpu.template → clarifai-10.11.0/clarifai/runners/dockerfile_template/Dockerfile.template

@@ -1,16 +1,16 @@
-ARG PYTHON_VERSION=${PYTHON_VERSION}
-FROM public.ecr.aws/docker/library/python:${PYTHON_VERSION}-slim-bookworm as build
+FROM --platform=$TARGETPLATFORM ${BASE_IMAGE} as build
 
-# Set the working directory to /app
-WORKDIR /app
+ENV DEBIAN_FRONTEND=noninteractive
 
+#############################
+# User specific requirements
+#############################
 COPY requirements.txt .
-# Install requirements and cleanup before leaving this line.
-# Note(zeiler): this could be in a future template as {{model_python_deps}}
-RUN python -m pip install -r requirements.txt && rm -rf /root/.cache
 
-# Install Clarifai SDK
-RUN python -m pip install clarifai
+# Install requirements and clarifai package and cleanup before leaving this line.
+# Note(zeiler): this could be in a future template as {{model_python_deps}}
+RUN pip install --no-cache-dir -r requirements.txt && \
+    pip install --no-cache-dir clarifai
 
 # These will be set by the templaing system.
 ENV CLARIFAI_PAT=${CLARIFAI_PAT}
@@ -20,12 +20,22 @@ ENV CLARIFAI_NODEPOOL_ID=${CLARIFAI_NODEPOOL_ID}
 ENV CLARIFAI_COMPUTE_CLUSTER_ID=${CLARIFAI_COMPUTE_CLUSTER_ID}
 ENV CLARIFAI_API_BASE=${CLARIFAI_API_BASE}
 
+# Set the NUMBA cache dir to /tmp
+ENV NUMBA_CACHE_DIR=/tmp/numba_cache
+ENV HOME=/tmp
+
+# Set the working directory to /app
+WORKDIR /app
+
 # Copy the current folder into /app/model_dir that the SDK will expect.
+# Note(zeiler): would be nice to exclude checkpoints in case they were pre-downloaded.
 COPY . /app/model_dir/${name}
 
 # Add the model directory to the python path.
-ENV PYTHONPATH "${PYTHONPATH}:/app/model_dir/${name}"
+ENV PYTHONPATH=${PYTHONPATH}:/app/model_dir/${name}
+
+ENTRYPOINT ["python", "-m", "clarifai.runners.server"]
 
 # Finally run the clarifai entrypoint to start the runner loop and local dev server.
 # Note(zeiler): we may want to make this a clarifai CLI call.
-CMD ["python", "-m", "clarifai.runners.server", "--model_path", "/app/model_dir/${name}"]
+CMD ["--model_path", "/app/model_dir/main"]

{clarifai-10.10.0 → clarifai-10.11.0}/clarifai/runners/models/base_typed_model.py

@@ -24,7 +24,8 @@ class AnyAnyModel(ModelRunner):
     list_input_dict = [
         InputDataHandler.from_proto(input).to_python() for input in input_request.inputs
     ]
-    inference_params = json_format.MessageToDict(input_request.model.output_info.params)
+    inference_params = json_format.MessageToDict(
+        input_request.model.model_version.output_info.params)
 
     return list_input_dict, inference_params
 
@@ -141,7 +142,8 @@ class VisualInputModel(AnyAnyModel):
     list_input_dict = [
         InputDataHandler.from_proto(input).image(format="np") for input in input_request.inputs
     ]
-    inference_params = json_format.MessageToDict(input_request.model.output_info.params)
+    inference_params = json_format.MessageToDict(
+        input_request.model.model_version.output_info.params)
 
     return list_input_dict, inference_params
 
@@ -181,7 +183,8 @@ class TextInputModel(AnyAnyModel):
   def parse_input_request(
       self, input_request: service_pb2.PostModelOutputsRequest) -> Tuple[List[Dict], Dict]:
     list_input_text = [InputDataHandler.from_proto(input).text for input in input_request.inputs]
-    inference_params = json_format.MessageToDict(input_request.model.output_info.params)
+    inference_params = json_format.MessageToDict(
+        input_request.model.model_version.output_info.params)
 
     return list_input_text, inference_params
 

{clarifai-10.10.0 → clarifai-10.11.0}/clarifai/runners/models/model_run_locally.py

@@ -1,3 +1,4 @@
+import hashlib
 import importlib.util
 import inspect
 import os
@@ -13,6 +14,7 @@ from clarifai_grpc.grpc.api.status import status_code_pb2, status_pb2
 from clarifai_protocol import BaseRunner
 
 from clarifai.runners.models.model_upload import ModelUploader
+from clarifai.runners.utils.url_fetcher import ensure_urls_downloaded
 from clarifai.utils.logging import logger
 
 
@@ -24,17 +26,26 @@ class ModelRunLocally:
 
   def create_temp_venv(self):
     """Create a temporary virtual environment."""
-    logger.info("Creating temporary virtual environment...")
-    temp_dir = tempfile.mkdtemp()
+    with open(self.requirements_file, "r") as f:
+      requirements_hash = hashlib.md5(f.read().encode('utf-8')).hexdigest()
+
+    temp_dir = os.path.join(tempfile.gettempdir(), str(requirements_hash))
     venv_dir = os.path.join(temp_dir, "venv")
-    venv.create(venv_dir, with_pip=True)
+
+    if os.path.exists(temp_dir):
+      logger.info(f"Using previous virtual environment at {temp_dir}")
+      use_existing_venv = True
+    else:
+      logger.info("Creating temporary virtual environment...")
+      use_existing_venv = False
+      venv.create(venv_dir, with_pip=True)
+      logger.info(f"Created temporary virtual environment at {venv_dir}")
 
     self.venv_dir = venv_dir
     self.temp_dir = temp_dir
     self.python_executable = os.path.join(venv_dir, "bin", "python")
 
-    logger.info(f"Created temporary virtual environment at {venv_dir}")
-    return venv_dir, temp_dir
+    return use_existing_venv
 
   def install_requirements(self):
     """Install the dependencies from requirements.txt and Clarifai."""
@@ -102,6 +113,8 @@ class ModelRunLocally:
     """Perform inference using the runner."""
     request = self._build_request()
 
+    ensure_urls_downloaded(request)
+
     try:
       return runner.predict(request)
     except Exception as e:
@@ -175,16 +188,18 @@ class ModelRunLocally:
       shutil.rmtree(self.temp_dir)
 
 
-def main(model_path, run_model_server=False):
+def main(model_path, run_model_server=False, keep_env=False):
 
   manager = ModelRunLocally(model_path)
-  manager.create_temp_venv()
+  use_existing_env = manager.create_temp_venv()
 
   try:
-    manager.install_requirements()
+    if not use_existing_env:
+      manager.install_requirements()
     if run_model_server:
       manager.run_model_server()
     else:
       manager.test_model()
   finally:
-    manager.clean_up()
+    if not keep_env:
+      manager.clean_up()

{clarifai-10.10.0 → clarifai-10.11.0}/clarifai/runners/models/model_upload.py

@@ -1,4 +1,5 @@
 import os
+import re
 import time
 from string import Template
 
@@ -23,6 +24,44 @@ def _clear_line(n: int = 1) -> None:
 
 class ModelUploader:
   DEFAULT_PYTHON_VERSION = 3.11
+  DEFAULT_TORCH_VERSION = '2.4.0'
+  DEFAULT_CUDA_VERSION = '124'
+  # List of available torch images for matrix
+  '''
+        python_version: ['3.8', '3.9', '3.10', '3.11']
+        torch_version: ['2.0.0', '2.1.0', '2.2.0', '2.3.0', '2.4.0', '2.4.1', '2.5.0']
+        cuda_version: ['124']
+  '''
+  AVAILABLE_TORCH_IMAGES = [
+      '2.0.0-py3.8-cuda124',
+      '2.0.0-py3.9-cuda124',
+      '2.0.0-py3.10-cuda124',
+      '2.0.0-py3.11-cuda124',
+      '2.1.0-py3.8-cuda124',
+      '2.1.0-py3.9-cuda124',
+      '2.1.0-py3.10-cuda124',
+      '2.1.0-py3.11-cuda124',
+      '2.2.0-py3.8-cuda124',
+      '2.2.0-py3.9-cuda124',
+      '2.2.0-py3.10-cuda124',
+      '2.2.0-py3.11-cuda124',
+      '2.3.0-py3.8-cuda124',
+      '2.3.0-py3.9-cuda124',
+      '2.3.0-py3.10-cuda124',
+      '2.3.0-py3.11-cuda124',
+      '2.4.0-py3.8-cuda124',
+      '2.4.0-py3.9-cuda124',
+      '2.4.0-py3.10-cuda124',
+      '2.4.0-py3.11-cuda124',
+      '2.4.1-py3.8-cuda124',
+      '2.4.1-py3.9-cuda124',
+      '2.4.1-py3.10-cuda124',
+      '2.4.1-py3.11-cuda124',
+  ]
+  AVAILABLE_PYTHON_IMAGES = ['3.8', '3.9', '3.10', '3.11', '3.12', '3.13']
+  PYTHON_BASE_IMAGE = 'public.ecr.aws/clarifai-models/python-base:{python_version}'
+  TORCH_BASE_IMAGE = 'public.ecr.aws/clarifai-models/torch:{torch_version}-py{python_version}-cuda{cuda_version}'
+
   CONCEPTS_REQUIRED_MODEL_TYPE = [
       'visual-classifier', 'visual-detector', 'visual-segmenter', 'text-classifier'
   ]
@@ -87,7 +126,7 @@ class ModelUploader:
       user_id = model.get('user_id')
       app_id = model.get('app_id')
 
-      base = os.environ.get('CLARIFAI_API_BASE', 'https://api-dev.clarifai.com')
+      base = os.environ.get('CLARIFAI_API_BASE', 'https://api.clarifai.com')
 
       self._client = BaseClient(user_id=user_id, app_id=app_id, base=base)
 
@@ -144,18 +183,46 @@ class ModelUploader:
     )
     return self.client.STUB.PostModels(request)
 
+  def _parse_requirements(self):
+    # parse the user's requirements.txt to determine the proper base image to build on top of, based on the torch and other large dependencies and it's versions
+    # List of dependencies to look for
+    dependencies = [
+        'torch',
+    ]
+    # Escape dependency names for regex
+    dep_pattern = '|'.join(map(re.escape, dependencies))
+    # All possible version specifiers
+    version_specifiers = '==|>=|<=|!=|~=|>|<'
+    # Compile a regex pattern with verbose mode for readability
+    pattern = re.compile(r"""
+          ^\s*                                   # Start of line, optional whitespace
+          (?P<dependency>""" + dep_pattern + r""")   # Dependency name
+          \s*                                   # Optional whitespace
+          (?P<specifier>""" + version_specifiers + r""")?  # Optional version specifier
+          \s*                                   # Optional whitespace
+          (?P<version>[^\s;]+)?                 # Optional version (up to space or semicolon)
+          """, re.VERBOSE)
+
+    deendencies_version = {}
+    with open(os.path.join(self.folder, 'requirements.txt'), 'r') as file:
+      for line in file:
+        # Skip empty lines and comments
+        line = line.strip()
+        if not line or line.startswith('#'):
+          continue
+        match = pattern.match(line)
+        if match:
+          dependency = match.group('dependency')
+          version = match.group('version')
+          deendencies_version[dependency] = version if version else None
+    return deendencies_version
+
   def create_dockerfile(self):
-    num_accelerators = self.inference_compute_info.num_accelerators
-    if num_accelerators:
-      dockerfile_template = os.path.join(
-          os.path.dirname(os.path.dirname(__file__)),
-          'dockerfile_template',
-          'Dockerfile.cuda.template',
-      )
-    else:
-      dockerfile_template = os.path.join(
-          os.path.dirname(os.path.dirname(__file__)), 'dockerfile_template',
-          'Dockerfile.cpu.template')
+    dockerfile_template = os.path.join(
+        os.path.dirname(os.path.dirname(__file__)),
+        'dockerfile_template',
+        'Dockerfile.template',
+    )
 
     with open(dockerfile_template, 'r') as template_file:
       dockerfile_template = template_file.read()
@@ -166,6 +233,11 @@ class ModelUploader:
     build_info = self.config.get('build_info', {})
     if 'python_version' in build_info:
       python_version = build_info['python_version']
+      if python_version not in self.AVAILABLE_PYTHON_IMAGES:
+        logger.error(
+            f"Python version {python_version} not supported, please use one of the following versions: {self.AVAILABLE_PYTHON_IMAGES}"
+        )
+        return
       logger.info(
           f"Using Python version {python_version} from the config file to build the Dockerfile")
     else:
@@ -174,10 +246,26 @@ class ModelUploader:
       )
       python_version = self.DEFAULT_PYTHON_VERSION
 
+    base_image = self.PYTHON_BASE_IMAGE.format(python_version=python_version)
+
+    # Parse the requirements.txt file to determine the base image
+    dependencies = self._parse_requirements()
+    if 'torch' in dependencies and dependencies['torch']:
+      torch_version = dependencies['torch']
+
+      for image in self.AVAILABLE_TORCH_IMAGES:
+        if torch_version in image and f'py{python_version}' in image:
+          base_image = self.TORCH_BASE_IMAGE.format(
+              torch_version=torch_version,
+              python_version=python_version,
+              cuda_version=self.DEFAULT_CUDA_VERSION)
+          logger.info(f"Using Torch version {torch_version} base image  to build the Docker image")
+          break
+
     # Replace placeholders with actual values
     dockerfile_content = dockerfile_template.safe_substitute(
-        PYTHON_VERSION=python_version,
         name='main',
+        BASE_IMAGE=base_image,
     )
 
     # Write Dockerfile

{clarifai-10.10.0 → clarifai-10.11.0}/clarifai/runners/utils/url_fetcher.py

@@ -6,25 +6,32 @@ from clarifai.utils.logging import logger
 
 
 def download_input(input):
+  _download_input_data(input.data)
+  if input.data.parts:
+    for i in range(len(input.data.parts)):
+      _download_input_data(input.data.parts[i].data)
+
+
+def _download_input_data(input_data):
   """
   This function will download any urls that are not already bytes.
   """
-  if input.data.image.url and not input.data.image.base64:
+  if input_data.image.url and not input_data.image.base64:
     # Download the image
-    with fsspec.open(input.data.image.url, 'rb') as f:
-      input.data.image.base64 = f.read()
-  if input.data.video.url and not input.data.video.base64:
+    with fsspec.open(input_data.image.url, 'rb') as f:
+      input_data.image.base64 = f.read()
+  if input_data.video.url and not input_data.video.base64:
     # Download the video
-    with fsspec.open(input.data.video.url, 'rb') as f:
-      input.data.video.base64 = f.read()
-  if input.data.audio.url and not input.data.audio.base64:
+    with fsspec.open(input_data.video.url, 'rb') as f:
+      input_data.video.base64 = f.read()
+  if input_data.audio.url and not input_data.audio.base64:
     # Download the audio
-    with fsspec.open(input.data.audio.url, 'rb') as f:
-      input.data.audio.base64 = f.read()
-  if input.data.text.url and not input.data.text.raw:
+    with fsspec.open(input_data.audio.url, 'rb') as f:
+      input_data.audio.base64 = f.read()
+  if input_data.text.url and not input_data.text.raw:
     # Download the text
-    with fsspec.open(input.data.text.url, 'r') as f:
-      input.data.text.raw = f.read()
+    with fsspec.open(input_data.text.url, 'r') as f:
+      input_data.text.raw = f.read()
 
 
 def ensure_urls_downloaded(request, max_threads=128):

{clarifai-10.10.0 → clarifai-10.11.0/clarifai.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: clarifai
-Version: 10.10.0
+Version: 10.11.0
 Summary: Clarifai Python SDK
 Home-page: https://github.com/Clarifai/clarifai-python
 Author: Clarifai
@@ -20,7 +20,7 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: clarifai-grpc>=10.9.11
+Requires-Dist: clarifai-grpc>=10.10.2
 Requires-Dist: clarifai-protocol>=0.0.6
 Requires-Dist: numpy>=1.22.0
 Requires-Dist: tqdm>=4.65.0

{clarifai-10.10.0 → clarifai-10.11.0}/clarifai.egg-info/SOURCES.txt

@@ -74,8 +74,7 @@ clarifai/rag/rag.py
 clarifai/rag/utils.py
 clarifai/runners/__init__.py
 clarifai/runners/server.py
-clarifai/runners/dockerfile_template/Dockerfile.cpu.template
-clarifai/runners/dockerfile_template/Dockerfile.cuda.template
+clarifai/runners/dockerfile_template/Dockerfile.template
 clarifai/runners/models/__init__.py
 clarifai/runners/models/base_typed_model.py
 clarifai/runners/models/model_class.py

{clarifai-10.10.0 → clarifai-10.11.0}/clarifai.egg-info/requires.txt

@@ -1,4 +1,4 @@
-clarifai-grpc>=10.9.11
+clarifai-grpc>=10.10.2
 clarifai-protocol>=0.0.6
 numpy>=1.22.0
 tqdm>=4.65.0

{clarifai-10.10.0 → clarifai-10.11.0}/pyproject.toml

@@ -1,2 +1,2 @@
 [tool.pytest.ini_options]
-markers = ["requires_secrets: mark a test as requiring secrets to run"]
+markers = ["requires_secrets: mark a test as requiring secrets to run", "coverage_only: mark a test as required to run for coverage purpose only"]

{clarifai-10.10.0 → clarifai-10.11.0}/requirements.txt

@@ -1,4 +1,4 @@
-clarifai-grpc>=10.9.11
+clarifai-grpc>=10.10.2
 clarifai-protocol>=0.0.6
 numpy>=1.22.0
 tqdm>=4.65.0

{clarifai-10.10.0 → clarifai-10.11.0}/tests/test_app.py

@@ -28,21 +28,32 @@ OBJECT_CONCEPT_ID = 'food'
 PREDICATE = "hypernym"
 
 CLARIFAI_PAT = os.environ["CLARIFAI_PAT"]
+CLARIFAI_API_BASE = os.environ.get("CLARIFAI_API_BASE", "https://api.clarifai.com")
 
 
 @pytest.fixture
 def create_app():
-  return App(user_id=CREATE_APP_USER_ID, app_id=CREATE_APP_ID, pat=CLARIFAI_PAT)
+  return App(
+      user_id=CREATE_APP_USER_ID,
+      app_id=CREATE_APP_ID,
+      pat=CLARIFAI_PAT,
+      base_url=CLARIFAI_API_BASE)
 
 
 @pytest.fixture
 def app():
-  return App(user_id=MAIN_APP_USER_ID, app_id=MAIN_APP_ID, pat=CLARIFAI_PAT)
+  return App(
+      user_id=MAIN_APP_USER_ID, app_id=MAIN_APP_ID, pat=CLARIFAI_PAT, base_url=CLARIFAI_API_BASE)
+
+
+@pytest.fixture
+def create_client():
+  return User(user_id=CREATE_APP_USER_ID, pat=CLARIFAI_PAT, base_url=CLARIFAI_API_BASE)
 
 
 @pytest.fixture
 def client():
-  return User(user_id=MAIN_APP_USER_ID, pat=CLARIFAI_PAT)
+  return User(user_id=MAIN_APP_USER_ID, pat=CLARIFAI_PAT, base_url=CLARIFAI_API_BASE)
 
 
 @pytest.mark.requires_secrets
@@ -60,7 +71,7 @@ class TestApp:
 
   def test_list_models(self, app):
     all_models = list(app.list_models(page_no=1))
-    assert len(all_models) == 15  #default per_page is 15
+    assert len(all_models) >= 15  #default per_page is 16
 
   def test_list_workflows(self, app):
     all_workflows = list(app.list_workflows(page_no=1, per_page=10))
@@ -68,7 +79,7 @@ class TestApp:
 
   def test_list_modules(self, app):
     all_modules = list(app.list_modules())
-    assert len(all_modules) == 1
+    assert len(all_modules) >= 0
 
   def test_list_installed_module_versions(self, app):
     all_installed_module_versions = list(app.list_installed_module_versions())
@@ -95,8 +106,8 @@ class TestApp:
     assert len(versions) == 1  #test for list_versions
     assert workflow.id == General_Workflow_ID and workflow.app_id == MAIN_APP_ID and workflow.user_id == MAIN_APP_USER_ID
 
-  def test_create_app(self):
-    app = User(user_id=CREATE_APP_USER_ID, pat=CLARIFAI_PAT).create_app(app_id=CREATE_APP_ID)
+  def test_create_app(self, create_client):
+    app = create_client.create_app(app_id=CREATE_APP_ID)
     assert app.id == CREATE_APP_ID and app.user_id == CREATE_APP_USER_ID
 
   def test_create_search(self, create_app):
@@ -149,9 +160,9 @@ class TestApp:
     all_concept_relations = list(create_app.search_concept_relations(show_tree=True))
     assert len(all_concept_relations) == 1
 
-  def test_patch_app(self, caplog):
+  def test_patch_app(self, create_client, caplog):
     with caplog.at_level(logging.INFO):
-      User(user_id=CREATE_APP_USER_ID).patch_app(
+      create_client.patch_app(
           app_id=CREATE_APP_ID,
           action='overwrite',
           default_language='en',
@@ -221,7 +232,7 @@ class TestApp:
   #     client.delete_runner(CREATE_RUNNER_ID)
   #     assert "SUCCESS" in caplog.text
 
-  def test_delete_app(self, caplog):
+  def test_delete_app(self, caplog, create_client):
     with caplog.at_level(logging.INFO):
-      User(user_id=CREATE_APP_USER_ID).delete_app(CREATE_APP_ID)
+      create_client.delete_app(CREATE_APP_ID)
       assert "SUCCESS" in caplog.text