clarifai 10.10.1__tar.gz → 10.11.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: clarifai
-Version: 10.10.1
+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.1 → 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.1 → 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.1 → 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.1 → 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.1 → 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.1 → clarifai-10.11.0}/clarifai/runners/models/model_upload.py

@@ -126,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)
 

{clarifai-10.10.1 → 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.1 → clarifai-10.11.0/clarifai.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: clarifai
-Version: 10.10.1
+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.1 → 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.1 → 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.1 → 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.1 → 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

{clarifai-10.10.1 → clarifai-10.11.0}/tests/test_data_upload.py

@@ -33,10 +33,11 @@ COCO_DET_DIR = os.path.dirname(__file__) + "/assets/coco_detection"
 IMAGENET_DIR = os.path.dirname(__file__) + "/assets/imagenet_classification"
 TEXTS_FOLDER_PATH = os.path.dirname(__file__) + "/assets/sample_texts"
 
+CLARIFAI_API_BASE = os.environ.get("CLARIFAI_API_BASE", "https://api.clarifai.com")
 
-def create_app():
-  client = User(user_id=CREATE_APP_USER_ID)
-  return client.create_app(app_id=CREATE_APP_ID, base_workflow="Empty")
+
+def client():
+  return User(user_id=CREATE_APP_USER_ID, base_url=CLARIFAI_API_BASE)
 
 
 @pytest.mark.requires_secrets
@@ -58,7 +59,7 @@ class Testdataupload:
 
   @classmethod
   def setup_class(self):
-    self.app = create_app()
+    self.app = client().create_app(app_id=CREATE_APP_ID, base_workflow="Empty")
     self.input_object = self.app.inputs()
     self.dataset = self.app.create_dataset(dataset_id=CREATE_DATASET_ID)
     self.dataset_new = self.app.create_dataset(dataset_id=CREATE_DATASET_NEW_ID)
@@ -285,4 +286,4 @@ class Testdataupload:
   @classmethod
   def teardown_class(self):
     self.app.delete_dataset(dataset_id=CREATE_DATASET_ID)
-    User(user_id=CREATE_APP_USER_ID).delete_app(app_id=CREATE_APP_ID)
+    client().delete_app(app_id=CREATE_APP_ID)

{clarifai-10.10.1 → clarifai-10.11.0}/tests/test_eval.py

@@ -17,10 +17,11 @@ CREATE_DATASET_NEW_ID = "ci_input_test_dataset_new"
 CREATE_MODEL_ID = "ci_input_test_model_1"
 CSV_FILE_PATH = os.path.dirname(__file__) + "/assets/sample.csv"
 
+CLARIFAI_API_BASE = os.environ.get("CLARIFAI_API_BASE", "https://api.clarifai.com")
 
-def create_app():
-  client = User(user_id=CREATE_APP_USER_ID)
-  return client.create_app(app_id=CREATE_APP_ID, base_workflow="Universal")
+
+def client():
+  return User(user_id=CREATE_APP_USER_ID, base_url=CLARIFAI_API_BASE)
 
 
 @pytest.mark.requires_secrets
@@ -30,7 +31,7 @@ class TestEval:
 
   @classmethod
   def setup_class(self):
-    self.app = create_app()
+    self.app = client().create_app(app_id=CREATE_APP_ID, base_workflow="Universal")
     self.input_object = self.app.inputs()
     self.dataset = self.app.create_dataset(dataset_id=CREATE_DATASET_ID)
     self.dataset_new = self.app.create_dataset(dataset_id=CREATE_DATASET_NEW_ID)
@@ -126,4 +127,4 @@ class TestEval:
   def teardown_class(self):
     self.app.delete_model(model_id=CREATE_MODEL_ID)
     self.app.delete_dataset(dataset_id=CREATE_DATASET_ID)
-    User(user_id=CREATE_APP_USER_ID).delete_app(app_id=CREATE_APP_ID)
+    client().delete_app(app_id=CREATE_APP_ID)

{clarifai-10.10.1 → clarifai-10.11.0}/tests/test_model_predict.py

@@ -21,12 +21,27 @@ RAW_TEXT = "Hi my name is Jim."
 RAW_TEXT_BYTES = b"Hi my name is Jim."
 
 CLARIFAI_PAT = os.environ["CLARIFAI_PAT"]
+CLARIFAI_API_BASE = os.environ.get("CLARIFAI_API_BASE", "https://api.clarifai.com")
 
 
 @pytest.fixture
 def model():
   return Model(
-      user_id=MAIN_APP_USER_ID, app_id=MAIN_APP_ID, model_id=GENERAL_MODEL_ID, pat=CLARIFAI_PAT)
+      user_id=MAIN_APP_USER_ID,
+      app_id=MAIN_APP_ID,
+      model_id=GENERAL_MODEL_ID,
+      pat=CLARIFAI_PAT,
+      base_url=CLARIFAI_API_BASE)
+
+
+@pytest.fixture
+def clip_embed_model():
+  return Model(
+      user_id=MAIN_APP_USER_ID,
+      app_id=MAIN_APP_ID,
+      model_id=CLIP_EMBED_MODEL_ID,
+      pat=CLARIFAI_PAT,
+      base_url=CLARIFAI_API_BASE)
 
 
 def validate_concepts_length(response):
@@ -51,15 +66,13 @@ class TestModelPredict:
     response = model.predict_by_bytes(image_bytes, 'image')
     validate_concepts_length(response)
 
-  def test_predict_image_url_with_selected_concepts(self):
+  def test_predict_image_url_with_selected_concepts(self, model):
     selected_concepts = [
         resources_pb2.Concept(name="dog"),
         resources_pb2.Concept(name="cat"),
     ]
-    model_with_selected_concepts = Model(
-        user_id=MAIN_APP_USER_ID, app_id=MAIN_APP_ID, model_id=GENERAL_MODEL_ID)
 
-    response = model_with_selected_concepts.predict_by_url(
+    response = model.predict_by_url(
         DOG_IMAGE_URL, 'image', output_config=dict(select_concepts=selected_concepts))
     concepts = response.outputs[0].data.concepts
 
@@ -68,25 +81,14 @@ class TestModelPredict:
     cat_concept = next(c for c in concepts if c.name == "cat")
     assert dog_concept.value > cat_concept.value
 
-  def test_predict_image_url_with_min_value(self):
-    model_with_min_value = Model(
-        user_id=MAIN_APP_USER_ID,
-        app_id=MAIN_APP_ID,
-        model_id=GENERAL_MODEL_ID,
-    )
-
-    response = model_with_min_value.predict_by_url(
-        DOG_IMAGE_URL, 'image', output_config=dict(min_value=0.98))
+  def test_predict_image_url_with_min_value(self, model):
+    response = model.predict_by_url(DOG_IMAGE_URL, 'image', output_config=dict(min_value=0.98))
     assert len(response.outputs[0].data.concepts) > 0
     for c in response.outputs[0].data.concepts:
       assert c.value >= 0.98
 
-  def test_predict_image_url_with_max_concepts(self):
-    model_with_max_concepts = Model(
-        user_id=MAIN_APP_USER_ID, app_id=MAIN_APP_ID, model_id=GENERAL_MODEL_ID)
-
-    response = model_with_max_concepts.predict_by_url(
-        DOG_IMAGE_URL, 'image', output_config=dict(max_concepts=3))
+  def test_predict_image_url_with_max_concepts(self, model):
+    response = model.predict_by_url(DOG_IMAGE_URL, 'image', output_config=dict(max_concepts=3))
     assert len(response.outputs[0].data.concepts) == 3
 
   def test_failed_predicts(self, model):
@@ -103,15 +105,9 @@ class TestModelPredict:
     with pytest.raises(UserError):
       model.predict_by_url(DOG_IMAGE_URL, 'invalid_input_type')
 
-  def test_predict_video_url_with_custom_sample_ms(self):
-    model_with_custom_sample_ms = Model(
-        user_id=MAIN_APP_USER_ID,
-        app_id=MAIN_APP_ID,
-        model_id=GENERAL_MODEL_ID,
-    )
+  def test_predict_video_url_with_custom_sample_ms(self, model):
     video_proto = Inputs.get_input_from_url("", video_url=BEER_VIDEO_URL)
-    response = model_with_custom_sample_ms.predict(
-        [video_proto], output_config=dict(sample_ms=2000))
+    response = model.predict([video_proto], output_config=dict(sample_ms=2000))
     # The expected time per frame is the middle between the start and the end of the frame
     # (in milliseconds).
     expected_time = 1000
@@ -121,11 +117,8 @@ class TestModelPredict:
       assert frame.frame_info.time == expected_time
       expected_time += 2000
 
-  def test_text_embed_predict_with_raw_text(self):
+  def test_text_embed_predict_with_raw_text(self, clip_embed_model):
     clip_dim = 512
-    clip_embed_model = Model(
-        user_id=MAIN_APP_USER_ID, app_id=MAIN_APP_ID, model_id=CLIP_EMBED_MODEL_ID)
-
     input_text_proto = Inputs.get_input_from_bytes(
         "", text_bytes=RAW_TEXT.encode(encoding='UTF-8'))
     response = clip_embed_model.predict([input_text_proto])
@@ -134,9 +127,7 @@ class TestModelPredict:
     response = clip_embed_model.predict([input_text_proto])
     assert response.outputs[0].data.embeddings[0].num_dimensions == clip_dim
 
-  def test_model_load_info(self):
-    clip_embed_model = Model(
-        user_id=MAIN_APP_USER_ID, app_id=MAIN_APP_ID, model_id=CLIP_EMBED_MODEL_ID)
+  def test_model_load_info(self, clip_embed_model):
     assert len(clip_embed_model.kwargs) == 4
     clip_embed_model.load_info()
     assert len(clip_embed_model.kwargs) > 10

{clarifai-10.10.1 → clarifai-10.11.0}/tests/test_model_train.py

@@ -16,10 +16,11 @@ CREATE_MODEL_ID = "ci_input_test_model"
 CREATE_MODEL_ID_1 = "ci_input_test_model_1"
 CSV_FILE_PATH = os.path.dirname(__file__) + "/assets/sample.csv"
 
+CLARIFAI_API_BASE = os.environ.get("CLARIFAI_API_BASE", "https://api.clarifai.com")
 
-def create_app():
-  client = User(user_id=CREATE_APP_USER_ID)
-  return client.create_app(app_id=CREATE_APP_ID, base_workflow="Empty")
+
+def client():
+  return User(user_id=CREATE_APP_USER_ID, base_url=CLARIFAI_API_BASE)
 
 
 @pytest.mark.requires_secrets
@@ -29,7 +30,7 @@ class Testmodeltrain:
 
   @classmethod
   def setup_class(self):
-    self.app = create_app()
+    self.app = client().create_app(app_id=CREATE_APP_ID, base_workflow="Empty")
     self.input_object = self.app.inputs()
     self.dataset = self.app.create_dataset(dataset_id=CREATE_DATASET_ID)
     self.visual_classifier_model = self.app.create_model(
@@ -103,4 +104,4 @@ class Testmodeltrain:
     self.app.delete_dataset(dataset_id=CREATE_DATASET_ID)
     self.app.delete_model(model_id=CREATE_MODEL_ID)
     self.app.delete_model(model_id=CREATE_MODEL_ID_1)
-    User(user_id=CREATE_APP_USER_ID).delete_app(app_id=CREATE_APP_ID)
+    client().delete_app(app_id=CREATE_APP_ID)

{clarifai-10.10.1 → clarifai-10.11.0}/tests/test_rag.py

@@ -13,15 +13,21 @@ CREATE_APP_USER_ID = os.environ["CLARIFAI_USER_ID"]
 TEXT_FILE_PATH = os.path.dirname(__file__) + "/assets/sample.txt"
 PDF_URL = "https://samples.clarifai.com/test_doc.pdf"
 
+CLARIFAI_API_BASE = os.environ.get("CLARIFAI_API_BASE", "https://api.clarifai.com")
+
 auth_obj = namedtuple("auth", "ui")
 
 
+def client():
+  return User(user_id=CREATE_APP_USER_ID, base_url=CLARIFAI_API_BASE)
+
+
 @pytest.mark.requires_secrets
 class TestRAG:
 
   @classmethod
   def setup_class(self):
-    self.rag = RAG.setup(user_id=CREATE_APP_USER_ID)
+    self.rag = RAG.setup(user_id=CREATE_APP_USER_ID, base_url=CLARIFAI_API_BASE)
     wf = self.rag._prompt_workflow
     auth = auth_obj(ui="https://clarifai.com")
     self.workflow_url = ClarifaiUrlHelper(auth).clarifai_url(wf.user_id, wf.app_id, "workflows",
@@ -57,4 +63,4 @@ class TestRAG:
 
   @classmethod
   def teardown_class(self):
-    User(user_id=CREATE_APP_USER_ID).delete_app(self.rag._app.id)
+    client().delete_app(self.rag._app.id)

{clarifai-10.10.1 → clarifai-10.11.0}/tests/test_search.py

@@ -16,6 +16,8 @@ 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_API_BASE = os.environ.get("CLARIFAI_API_BASE", "https://api.clarifai.com")
+
 
 def get_filters_for_test() -> [(typing.List[typing.Dict], int)]:
   return [
@@ -109,13 +111,25 @@ class TestAnnotationSearch:
 
   @classmethod
   def setup_class(cls):
-    cls.client = User(user_id=CREATE_APP_USER_ID)
+    cls.client = User(user_id=CREATE_APP_USER_ID, base_url=CLARIFAI_API_BASE)
     cls.search = Search(
-        user_id=CREATE_APP_USER_ID, app_id=CREATE_APP_ID, top_k=1, metric="euclidean")
+        user_id=CREATE_APP_USER_ID,
+        app_id=CREATE_APP_ID,
+        base_url=CLARIFAI_API_BASE,
+        top_k=1,
+        metric="euclidean")
     cls.search_with_pagination = Search(
-        user_id=CREATE_APP_USER_ID, app_id=CREATE_APP_ID, metric="euclidean", pagination=True)
+        user_id=CREATE_APP_USER_ID,
+        app_id=CREATE_APP_ID,
+        base_url=CLARIFAI_API_BASE,
+        metric="euclidean",
+        pagination=True)
     cls.search_deduplicate = Search(
-        user_id=CREATE_APP_USER_ID, app_id=CREATE_APP_ID, top_k=2, metric="euclidean")
+        user_id=CREATE_APP_USER_ID,
+        app_id=CREATE_APP_ID,
+        base_url=CLARIFAI_API_BASE,
+        top_k=2,
+        metric="euclidean")
     cls.upload_data()
 
   @classmethod

clarifai-10.10.1/clarifai/__init__.py

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