clarifai 10.2.0__py3-none-any.whl → 10.3.0__py3-none-any.whl

clarifai/client/model.py

@@ -1,7 +1,8 @@
 import os
 import time
-from typing import Any, Dict, Generator, List, Union
+from typing import Any, Dict, Generator, List, Tuple, Union
 
+import numpy as np
 import requests
 import yaml
 from clarifai_grpc.grpc.api import resources_pb2, service_pb2
@@ -12,6 +13,7 @@ from google.protobuf.struct_pb2 import Struct
 from tqdm import tqdm
 
 from clarifai.client.base import BaseClient
+from clarifai.client.dataset import Dataset
 from clarifai.client.input import Inputs
 from clarifai.client.lister import Lister
 from clarifai.constants.model import MAX_MODEL_PREDICT_INPUTS, TRAINABLE_MODEL_TYPES
@@ -34,6 +36,7 @@ class Model(Lister, BaseClient):
                base_url: str = "https://api.clarifai.com",
                pat: str = None,
                token: str = None,
+               root_certificates_path: str = None,
                **kwargs):
     """Initializes a Model object.
 
@@ -44,6 +47,7 @@ class Model(Lister, BaseClient):
         base_url (str): Base API url. Default "https://api.clarifai.com"
         pat (str): A personal access token for authentication. Can be set as env var CLARIFAI_PAT
         token (str): A session token for authentication. Accepts either a session token or a pat. Can be set as env var CLARIFAI_SESSION_TOKEN
+        root_certificates_path (str): Path to the SSL root certificates file, used to establish secure gRPC connections.
         **kwargs: Additional keyword arguments to be passed to the Model.
     """
     if url and model_id:
@@ -59,7 +63,13 @@ class Model(Lister, BaseClient):
     self.logger = get_logger(logger_level="INFO", name=__name__)
     self.training_params = {}
     BaseClient.__init__(
-        self, user_id=self.user_id, app_id=self.app_id, base=base_url, pat=pat, token=token)
+        self,
+        user_id=self.user_id,
+        app_id=self.app_id,
+        base=base_url,
+        pat=pat,
+        token=token,
+        root_certificates_path=root_certificates_path)
     Lister.__init__(self)
 
   def list_training_templates(self) -> List[str]:
@@ -243,7 +253,7 @@ class Model(Lister, BaseClient):
 
     return response.model.model_version.id
 
-  def training_status(self, version_id: str, training_logs: bool = False) -> Dict[str, str]:
+  def training_status(self, version_id: str = None, training_logs: bool = False) -> Dict[str, str]:
     """Get the training status for the model version. Also stores training logs
 
     Args:
@@ -258,19 +268,20 @@ class Model(Lister, BaseClient):
         >>> model = Model(model_id='model_id', user_id='user_id', app_id='app_id')
         >>> model.training_status(version_id='version_id',training_logs=True)
     """
+    if not version_id and not self.model_info.model_version.id:
+      raise UserError(
+          "Model version ID is missing. Please provide a `model_version` with a valid `id` as an argument or as a URL in the following format: '{user_id}/{app_id}/models/{your_model_id}/model_version_id/{your_version_model_id}' when initializing."
+      )
+
+    if not self.model_info.model_type_id or not self.model_info.model_version.train_log:
+      self.load_info()
     if self.model_info.model_type_id not in TRAINABLE_MODEL_TYPES:
       raise UserError(f"Model type {self.model_info.model_type_id} is not trainable")
 
-    request = service_pb2.GetModelVersionRequest(
-        user_app_id=self.user_app_id, model_id=self.id, version_id=version_id)
-    response = self._grpc_request(self.STUB.GetModelVersion, request)
-    if response.status.code != status_code_pb2.SUCCESS:
-      raise Exception(response.status)
-
     if training_logs:
       try:
-        if response.model_version.train_log:
-          log_response = requests.get(response.model_version.train_log)
+        if self.model_info.model_version.train_log:
+          log_response = requests.get(self.model_info.model_version.train_log)
           log_response.raise_for_status()  # Check for any HTTP errors
           with open(version_id + '.log', 'wb') as file:
             for chunk in log_response.iter_content(chunk_size=4096):  # 4KB
@@ -280,7 +291,7 @@ class Model(Lister, BaseClient):
       except requests.exceptions.RequestException as e:
         raise Exception(f"An error occurred while getting training logs: {e}")
 
-    return response.model_version.status
+    return self.model_info.model_version.status
 
   def delete_version(self, version_id: str) -> None:
     """Deletes a model version for the Model.
@@ -407,7 +418,7 @@ class Model(Lister, BaseClient):
         model=self.model_info)
 
     start_time = time.time()
-    backoff_iterator = BackoffIterator()
+    backoff_iterator = BackoffIterator(10)
     while True:
       response = self._grpc_request(self.STUB.PostModelOutputs, request)
 
@@ -617,18 +628,22 @@ class Model(Lister, BaseClient):
     return response.eval_metrics
 
   def evaluate(self,
-               dataset_id: str,
+               dataset: Dataset = None,
+               dataset_id: str = None,
                dataset_app_id: str = None,
                dataset_user_id: str = None,
+               dataset_version_id: str = None,
                eval_id: str = None,
                extended_metrics: dict = None,
                eval_info: dict = None) -> resources_pb2.EvalMetrics:
     """ Run evaluation
 
     Args:
-      dataset_id (str): Dataset Id.
+      dataset (Dataset): If Clarifai Dataset is set, it will ignore other arguments prefixed with 'dataset_'.
+      dataset_id (str): Dataset Id. Default is None.
       dataset_app_id (str): App ID for cross app evaluation, leave it as None to use Model App ID. Default is None.
       dataset_user_id (str): User ID for cross app evaluation, leave it as None to use Model User ID. Default is None.
+      dataset_version_id (str): Dataset version Id. Default is None.
       eval_id (str): Specific ID for the evaluation. You must specify this parameter to either overwrite the result with the dataset ID or format your evaluation in an informative manner. If you don't, it will use random ID from system. Default is None.
       extended_metrics (dict): user custom metrics result. Default is None.
       eval_info (dict): custom eval info. Default is empty dict.
@@ -638,6 +653,23 @@ class Model(Lister, BaseClient):
 
     """
     assert self.model_info.model_version.id, "Model version is empty. Please provide `model_version` as arguments or with a URL as the format '{user_id}/{app_id}/models/{your_model_id}/model_version_id/{your_version_model_id}' when initializing."
+
+    if dataset:
+      self.logger.info("Using dataset, ignore other arguments prefixed with 'dataset_'")
+      dataset_id = dataset.id
+      dataset_app_id = dataset.app_id
+      dataset_user_id = dataset.user_id
+      dataset_version_id = dataset.version.id
+    else:
+      self.logger.warning(
+          "Arguments prefixed with `dataset_` will be removed soon, please use dataset")
+
+    gt_dataset = resources_pb2.Dataset(
+        id=dataset_id,
+        app_id=dataset_app_id or self.auth_helper.app_id,
+        user_id=dataset_user_id or self.auth_helper.user_id,
+        version=resources_pb2.DatasetVersion(id=dataset_version_id))
+
     metrics = None
     if isinstance(extended_metrics, dict):
       metrics = Struct()
@@ -659,11 +691,7 @@ class Model(Lister, BaseClient):
             model_version=resources_pb2.ModelVersion(id=self.model_info.model_version.id),
         ),
         extended_metrics=metrics,
-        ground_truth_dataset=resources_pb2.Dataset(
-            id=dataset_id,
-            app_id=dataset_app_id or self.auth_helper.app_id,
-            user_id=dataset_user_id or self.auth_helper.user_id,
-        ),
+        ground_truth_dataset=gt_dataset,
         eval_info=eval_info_params,
     )
     request = service_pb2.PostEvaluationsRequest(
@@ -761,6 +789,157 @@ class Model(Lister, BaseClient):
 
     return result
 
+  def get_eval_by_dataset(self, dataset: Dataset) -> List[resources_pb2.EvalMetrics]:
+    """Get all eval data of dataset
+
+    Args:
+        dataset (Dataset): Clarifai dataset
+
+    Returns:
+        List[resources_pb2.EvalMetrics]
+    """
+    _id = dataset.id
+    app = dataset.app_id or self.app_id
+    user_id = dataset.user_id or self.user_id
+    version = dataset.version.id
+
+    list_eval: resources_pb2.EvalMetrics = self.list_evaluations()
+    outputs = []
+    for _eval in list_eval:
+      if _eval.status.code == status_code_pb2.MODEL_EVALUATED:
+        gt_ds = _eval.ground_truth_dataset
+        if (_id == gt_ds.id and user_id == gt_ds.user_id and app == gt_ds.app_id):
+          if not version or version == gt_ds.version.id:
+            outputs.append(_eval)
+
+    return outputs
+
+  def get_raw_eval(self,
+                   dataset: Dataset = None,
+                   eval_id: str = None,
+                   return_format: str = 'array') -> Union[resources_pb2.EvalTestSetEntry, Tuple[
+                       np.array, np.array, list, List[Input]], Tuple[List[dict], List[dict]]]:
+    """Get ground truths, predictions and input information. Do not pass dataset and eval_id at same time
+
+    Args:
+        dataset (Dataset): Clarifai dataset, get eval data of latest eval result of dataset.
+        eval_id (str): Evaluation ID, get eval data of specific eval id.
+        return_format (str, optional): Choice {proto, array, coco}. !Note that `coco` is only applicable for 'visual-detector'. Defaults to 'array'.
+
+    Returns:
+
+        Depends on `return_format`.
+
+        * if return_format == proto
+          `resources_pb2.EvalTestSetEntry`
+
+        * if return_format == array
+          `Tuple(np.array, np.array, List[str], List[Input])`: Tuple has 4 elements (y, y_pred, concept_ids, inputs).
+            y, y_pred, concept_ids can be used to compute metrics. 'inputs' can be use to download
+            - if model is 'classifier': 'y' and 'y_pred' are both arrays with a shape of (num_inputs,)
+            - if model is 'visual-detector': 'y' and 'y_pred' are arrays with a shape of (num_inputs,), where each element is array has shape (num_annotation, 6) consists of [x_min, y_min, x_max, y_max, concept_index, score]. The score is always 1 for 'y'
+
+        * if return_format == coco: Applicable only for 'visual-detector'
+          `Tuple[List[Dict], List[Dict]]`: Tuple has 2 elemnts where first element is COCO Ground Truth and last one is COCO Prediction Annotation
+
+    Example Usages:
+    ------
+    * Evaluate `visual-classifier` using sklearn
+
+    ```python
+    import os
+    from sklearn.metrics import accuracy_score
+    from sklearn.metrics import classification_report
+    import numpy as np
+    from clarifai.client.model import Model
+    from clarifai.client.dataset import Dataset
+    os.environ["CLARIFAI_PAT"] = "???"
+    model = Model(url="url/of/model/includes/version-id")
+    dataset = Dataset(dataset_id="dataset-id")
+    y, y_pred, clss, input_protos = model.get_raw_eval(dataset, return_format="array")
+    y = np.argmax(y, axis=1)
+    y_pred = np.argmax(y_pred, axis=1)
+    report = classification_report(y, y_pred, target_names=clss)
+    print(report)
+    acc = accuracy_score(y, y_pred)
+    print("acc ", acc)
+    ```
+
+    * Evaluate `visual-detector` using COCOeval
+
+    ```python
+    import os
+    import json
+    from pycocotools.coco import COCO
+    from pycocotools.cocoeval import COCOeval
+    from clarifai.client.model import Model
+    from clarifai.client.dataset import Dataset
+    os.environ["CLARIFAI_PAT"] = "???" # Insert your PAT
+    model = Model(url=model_url)
+    dataset = Dataset(url=dataset_url)
+    y, y_pred = model.get_raw_eval(dataset, return_format="coco")
+    # save as files to load in COCO API
+    def save_annot(d, path):
+      with open(path, "w") as fp:
+        json.dump(d, fp, indent=2)
+    gt_path = os.path.join("gt.json")
+    pred_path = os.path.join("pred.json")
+    save_annot(y, gt_path)
+    save_annot(y_pred, pred_path)
+
+    cocoGt = COCO(gt_path)
+    cocoPred = COCO(pred_path)
+    cocoEval = COCOeval(cocoGt, cocoPred, "bbox")
+    cocoEval.evaluate()
+    cocoEval.accumulate()
+    cocoEval.summarize() # Print out result of all classes with all area type
+    # Example:
+    # Average Precision  (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 0.863
+    # Average Precision  (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 0.973
+    # Average Precision  (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 0.939
+    # ...
+    ```
+
+    """
+    from clarifai.utils.evaluation.testset_annotation_parser import (
+        parse_eval_annotation_classifier, parse_eval_annotation_detector,
+        parse_eval_annotation_detector_coco)
+
+    valid_model_types = ["visual-classifier", "text-classifier", "visual-detector"]
+    supported_format = ['proto', 'array', 'coco']
+    assert return_format in supported_format, ValueError(
+        f"Expected return_format in {supported_format}, got {return_format}")
+    self.load_info()
+    model_type_id = self.model_info.model_type_id
+    assert model_type_id in valid_model_types, \
+      f"This method only supports model types {valid_model_types}, but your model type is {self.model_info.model_type_id}."
+    assert not (dataset and
+                eval_id), "Using both `dataset` and `eval_id`, but only one should be passed."
+    assert not dataset or not eval_id, "Please provide either `dataset` or `eval_id`, but nothing was passed."
+    if model_type_id.endswith("-classifier") and return_format == "coco":
+      raise ValueError(
+          f"return_format coco only applies for `visual-detector`, however your model is `{model_type_id}`"
+      )
+
+    if dataset:
+      eval_by_ds = self.get_eval_by_dataset(dataset)
+      if len(eval_by_ds) == 0:
+        raise Exception(f"Model is not valuated with dataset: {dataset}")
+      eval_id = eval_by_ds[0].id
+
+    detail_eval_data = self.get_eval_by_id(eval_id=eval_id, test_set=True, metrics_by_class=True)
+
+    if return_format == "proto":
+      return detail_eval_data.test_set
+    else:
+      if model_type_id.endswith("-classifier"):
+        return parse_eval_annotation_classifier(detail_eval_data)
+      elif model_type_id == "visual-detector":
+        if return_format == "array":
+          return parse_eval_annotation_detector(detail_eval_data)
+        elif return_format == "coco":
+          return parse_eval_annotation_detector_coco(detail_eval_data)
+
   def export(self, export_dir: str = None) -> None:
     """Export the model, stores the exported model as model.tar file
 
@@ -830,7 +1009,7 @@ class Model(Lister, BaseClient):
       )
       time.sleep(5)
       start_time = time.time()
-      backoff_iterator = BackoffIterator()
+      backoff_iterator = BackoffIterator(10)
       while True:
         get_export_response = _get_export_response()
         if get_export_response.export.status.code == status_code_pb2.MODEL_EXPORTING and \
@@ -841,6 +1020,7 @@ class Model(Lister, BaseClient):
           time.sleep(next(backoff_iterator))
         elif get_export_response.export.status.code == status_code_pb2.MODEL_EXPORTED:
           _download_exported_model(get_export_response, os.path.join(export_dir, "model.tar"))
+          break
         elif time.time() - start_time > 60 * 30:
           raise Exception(
               f"""Model Export took too long. Please try again or contact support@clarifai.com

clarifai/client/module.py

@@ -19,6 +19,7 @@ class Module(Lister, BaseClient):
                base_url: str = "https://api.clarifai.com",
                pat: str = None,
                token: str = None,
+               root_certificates_path: str = None,
                **kwargs):
     """Initializes a Module object.
 
@@ -29,6 +30,7 @@ class Module(Lister, BaseClient):
             base_url (str): Base API url. Default "https://api.clarifai.com"
             pat (str): A personal access token for authentication. Can be set as env var CLARIFAI_PAT.
             token (str): A session token for authentication. Accepts either a session token or a pat. Can be set as env var CLARIFAI_SESSION_TOKEN.
+            root_certificates_path (str): Path to the SSL root certificates file, used to establish secure gRPC connections.
             **kwargs: Additional keyword arguments to be passed to the Module.
         """
     if url and module_id:
@@ -44,7 +46,13 @@ class Module(Lister, BaseClient):
     self.module_info = resources_pb2.Module(**self.kwargs)
     self.logger = get_logger(logger_level="INFO", name=__name__)
     BaseClient.__init__(
-        self, user_id=self.user_id, app_id=self.app_id, base=base_url, pat=pat, token=token)
+        self,
+        user_id=self.user_id,
+        app_id=self.app_id,
+        base=base_url,
+        pat=pat,
+        token=token,
+        root_certificates_path=root_certificates_path)
     Lister.__init__(self)
 
   def list_versions(self, page_no: int = None,

clarifai/client/search.py

@@ -24,7 +24,8 @@ class Search(Lister, BaseClient):
                metric: str = DEFAULT_SEARCH_METRIC,
                base_url: str = "https://api.clarifai.com",
                pat: str = None,
-               token: str = None):
+               token: str = None,
+               root_certificates_path: str = None):
     """Initialize the Search object.
 
     Args:
@@ -35,6 +36,7 @@ class Search(Lister, BaseClient):
         base_url (str, optional): Base API url. Defaults to "https://api.clarifai.com".
         pat (str, optional): A personal access token for authentication. Can be set as env var CLARIFAI_PAT
         token (str): A session token for authentication. Accepts either a session token or a pat. Can be set as env var CLARIFAI_SESSION_TOKEN
+        root_certificates_path (str): Path to the SSL root certificates file, used to establish secure gRPC connections.
 
     Raises:
         UserError: If the metric is not 'cosine' or 'euclidean'.
@@ -52,7 +54,13 @@ class Search(Lister, BaseClient):
         user_id=self.user_id, app_id=self.app_id, pat=pat, token=token, base_url=base_url)
     self.rank_filter_schema = get_schema()
     BaseClient.__init__(
-        self, user_id=self.user_id, app_id=self.app_id, base=base_url, pat=pat, token=token)
+        self,
+        user_id=self.user_id,
+        app_id=self.app_id,
+        base=base_url,
+        pat=pat,
+        token=token,
+        root_certificates_path=root_certificates_path)
     Lister.__init__(self, page_size=1000)
 
   def _get_annot_proto(self, **kwargs):

clarifai/client/user.py

@@ -7,7 +7,6 @@ from google.protobuf.json_format import MessageToDict
 from clarifai.client.app import App
 from clarifai.client.base import BaseClient
 from clarifai.client.lister import Lister
-from clarifai.client.runner import Runner
 from clarifai.errors import UserError
 from clarifai.utils.logging import get_logger
 
@@ -20,6 +19,7 @@ class User(Lister, BaseClient):
                base_url: str = "https://api.clarifai.com",
                pat: str = None,
                token: str = None,
+               root_certificates_path: str = None,
                **kwargs):
     """Initializes an User object.
 
@@ -28,12 +28,20 @@ class User(Lister, BaseClient):
         base_url (str): Base API url. Default "https://api.clarifai.com"
         pat (str): A personal access token for authentication. Can be set as env var CLARIFAI_PAT
         token (str): A session token for authentication. Accepts either a session token or a pat. Can be set as env var CLARIFAI_SESSION_TOKEN
+        root_certificates_path (str): Path to the SSL root certificates file, used to establish secure gRPC connections.
         **kwargs: Additional keyword arguments to be passed to the User.
     """
     self.kwargs = {**kwargs, 'id': user_id}
     self.user_info = resources_pb2.User(**self.kwargs)
     self.logger = get_logger(logger_level="INFO", name=__name__)
-    BaseClient.__init__(self, user_id=self.id, app_id="", base=base_url, pat=pat, token=token)
+    BaseClient.__init__(
+        self,
+        user_id=self.id,
+        app_id="",
+        base=base_url,
+        pat=pat,
+        token=token,
+        root_certificates_path=root_certificates_path)
     Lister.__init__(self)
 
   def list_apps(self, filter_by: Dict[str, Any] = {}, page_no: int = None,
@@ -69,7 +77,7 @@ class User(Lister, BaseClient):
           **app_info)  #(base_url=self.base, pat=self.pat, token=self.token, **app_info)
 
   def list_runners(self, filter_by: Dict[str, Any] = {}, page_no: int = None,
-                   per_page: int = None) -> Generator[Runner, None, None]:
+                   per_page: int = None) -> Generator[dict, None, None]:
     """List all runners for the user
 
     Args:
@@ -78,7 +86,7 @@ class User(Lister, BaseClient):
         per_page (int): The number of items per page.
 
     Yields:
-        Runner: Runner objects for the runners.
+        Dict: Dictionaries containing information about the runners.
 
     Example:
         >>> from clarifai.client.user import User
@@ -98,8 +106,7 @@ class User(Lister, BaseClient):
         page_no=page_no)
 
     for runner_info in all_runners_info:
-      yield Runner.from_auth_helper(
-          auth=self.auth_helper, check_runner_exists=False, **runner_info)
+      yield dict(auth=self.auth_helper, check_runner_exists=False, **runner_info)
 
   def create_app(self, app_id: str, base_workflow: str = 'Empty', **kwargs) -> App:
     """Creates an app for the user.
@@ -127,7 +134,7 @@ class User(Lister, BaseClient):
     self.logger.info("\nApp created\n%s", response.status)
     return App.from_auth_helper(auth=self.auth_helper, app_id=app_id)
 
-  def create_runner(self, runner_id: str, labels: List[str], description: str) -> Runner:
+  def create_runner(self, runner_id: str, labels: List[str], description: str) -> dict:
     """Create a runner
 
     Args:
@@ -136,13 +143,14 @@ class User(Lister, BaseClient):
       description (str): Description of Runner
 
     Returns:
-      Runner: A runner object for the specified Runner ID
+      Dict: A dictionary containing information about the specified Runner ID.
 
     Example:
         >>> from clarifai.client.user import User
         >>> client = User(user_id="user_id")
-        >>> runner = client.create_runner(runner_id="runner_id", labels=["label to link runner"], description="laptop runner")
+        >>> runner_info = client.create_runner(runner_id="runner_id", labels=["label to link runner"], description="laptop runner")
     """
+
     if not isinstance(labels, List):
       raise UserError("Labels must be a List of strings")
 
@@ -155,7 +163,7 @@ class User(Lister, BaseClient):
       raise Exception(response.status)
     self.logger.info("\nRunner created\n%s", response.status)
 
-    return Runner.from_auth_helper(
+    return dict(
         auth=self.auth_helper,
         runner_id=runner_id,
         user_id=self.id,
@@ -186,19 +194,19 @@ class User(Lister, BaseClient):
     kwargs['user_id'] = self.id
     return App.from_auth_helper(auth=self.auth_helper, app_id=app_id, **kwargs)
 
-  def runner(self, runner_id: str) -> Runner:
+  def runner(self, runner_id: str) -> dict:
     """Returns a Runner object if exists.
 
     Args:
         runner_id (str): The runner ID to interact with
 
     Returns:
-        Runner: A Runner object for the existing runner ID.
+        Dict: A dictionary containing information about the existing runner ID.
 
     Example:
         >>> from clarifai.client.user import User
         >>> client = User(user_id="user_id")
-        >>> runner = client.runner(runner_id="runner_id")
+        >>> runner_info = client.runner(runner_id="runner_id")
     """
     request = service_pb2.GetRunnerRequest(user_app_id=self.user_app_id, runner_id=runner_id)
     response = self._grpc_request(self.STUB.GetRunner, request)
@@ -212,7 +220,7 @@ class User(Lister, BaseClient):
     kwargs = self.process_response_keys(dict_response[list(dict_response.keys())[1]],
                                         list(dict_response.keys())[1])
 
-    return Runner.from_auth_helper(self.auth_helper, check_runner_exists=False, **kwargs)
+    return dict(self.auth_helper, check_runner_exists=False, **kwargs)
 
   def delete_app(self, app_id: str) -> None:
     """Deletes an app for the user.

clarifai/client/workflow.py

@@ -28,6 +28,7 @@ class Workflow(Lister, BaseClient):
                base_url: str = "https://api.clarifai.com",
                pat: str = None,
                token: str = None,
+               root_certificates_path: str = None,
                **kwargs):
     """Initializes a Workflow object.
 
@@ -43,6 +44,7 @@ class Workflow(Lister, BaseClient):
         base_url (str): Base API url. Default "https://api.clarifai.com"
         pat (str): A personal access token for authentication. Can be set as env var CLARIFAI_PAT
         token (str): A session token for authentication. Accepts either a session token or a pat. Can be set as env var CLARIFAI_SESSION_TOKEN
+        root_certificates_path (str): Path to the SSL root certificates file, used to establish secure gRPC connections.
         **kwargs: Additional keyword arguments to be passed to the Workflow.
     """
     if url and workflow_id:
@@ -59,7 +61,13 @@ class Workflow(Lister, BaseClient):
     self.workflow_info = resources_pb2.Workflow(**self.kwargs)
     self.logger = get_logger(logger_level="INFO", name=__name__)
     BaseClient.__init__(
-        self, user_id=self.user_id, app_id=self.app_id, base=base_url, pat=pat, token=token)
+        self,
+        user_id=self.user_id,
+        app_id=self.app_id,
+        base=base_url,
+        pat=pat,
+        token=token,
+        root_certificates_path=root_certificates_path)
     Lister.__init__(self)
 
   def predict(self, inputs: List[Input], workflow_state_id: str = None):
@@ -83,7 +91,7 @@ class Workflow(Lister, BaseClient):
       request.workflow_state.id = workflow_state_id
 
     start_time = time.time()
-    backoff_iterator = BackoffIterator()
+    backoff_iterator = BackoffIterator(10)
 
     while True:
       response = self._grpc_request(self.STUB.PostWorkflowResults, request)

clarifai/constants/input.py

@@ -0,0 +1 @@
+MAX_UPLOAD_BATCH_SIZE = 128

clarifai/datasets/export/inputs_annotations.py

@@ -21,7 +21,7 @@ logger = get_logger("INFO", __name__)
 class DatasetExportReader:
 
   def __init__(self,
-               session: requests.Session,
+               session: requests.Session = None,
                archive_url: Optional[str] = None,
                local_archive_path: Optional[str] = None):
     """Download/Reads the zipfile archive and yields every api.Input object.
@@ -31,9 +31,11 @@ class DatasetExportReader:
         archive_url: URL of the DatasetVersionExport archive
         local_archive_path: Path to the DatasetVersionExport archive
     """
-    self.input_count = 0
+    self.input_count = None
     self.temp_file = None
     self.session = session
+    if not self.session:
+      self.session = requests.Session()
 
     assert archive_url or local_archive_path, UserError(
         "Either archive_url or local_archive_path must be provided.")
@@ -59,7 +61,8 @@ class DatasetExportReader:
   def _download_temp_archive(self, archive_url: str,
                              chunk_size: int = 128) -> tempfile.TemporaryFile:
     """Downloads the temp archive of InputBatches."""
-    r = self.session.get(archive_url, stream=True)
+    session = requests.Session()
+    r = session.get(archive_url, stream=True)
     temp_file = tempfile.TemporaryFile()
     for chunk in r.iter_content(chunk_size=chunk_size):
       temp_file.write(chunk)
@@ -67,10 +70,12 @@ class DatasetExportReader:
     return temp_file
 
   def __len__(self) -> int:
-    if not self.input_count:
+    if self.input_count is None:
+      input_count = 0
       if self.file_name_list is not None:
         for filename in self.file_name_list:
-          self.input_count += int(filename.split('_n')[-1])
+          input_count += int(filename.split('_n')[-1])
+      self.input_count = input_count
 
     return self.input_count
 
@@ -111,7 +116,8 @@ class InputAnnotationDownloader:
     """
     self.input_iterator = input_iterator
     self.num_workers = min(num_workers, 10)  # Max 10 threads
-    self.num_inputs_annotations = 0
+    self.num_inputs = 0
+    self.num_annotations = 0
     self.split_prefix = None
     self.session = session
     self.input_ext = dict(image=".png", text=".txt", audio=".mp3", video=".mp4")
@@ -182,14 +188,14 @@ class InputAnnotationDownloader:
         self._save_audio_to_archive(new_archive, hosted_url, file_name)
       elif input_type == "video":
         self._save_video_to_archive(new_archive, hosted_url, file_name)
-      self.num_inputs_annotations += 1
+      self.num_inputs += 1
 
     if data_dict.get("concepts") or data_dict.get("regions"):
       file_name = os.path.join(split, "annotations", input_.id + ".json")
       annot_data = data_dict.get("concepts") or data_dict.get("regions")
 
       self._save_annotation_to_archive(new_archive, annot_data, file_name)
-      self.num_inputs_annotations += 1
+      self.num_annotations += 1
 
   def _check_output_archive(self, save_path: str) -> None:
     try:
@@ -198,8 +204,8 @@ class InputAnnotationDownloader:
       raise e
     assert len(
         archive.namelist()
-    ) == self.num_inputs_annotations, "Archive has %d inputs+annotations | expecting %d inputs+annotations" % (
-        len(archive.namelist()), self.num_inputs_annotations)
+    ) == self.num_inputs + self.num_annotations, "Archive has %d inputs+annotations | expecting %d inputs+annotations" % (
+        len(archive.namelist()), self.num_inputs + self.num_annotations)
 
   def download_archive(self, save_path: str, split: Optional[str] = None) -> None:
     """Downloads the archive from the URL into an archive of inputs, annotations in the directory format
@@ -218,5 +224,5 @@ class InputAnnotationDownloader:
             progress.update()
 
     self._check_output_archive(save_path)
-    logger.info("Downloaded %d inputs+annotations to %s" % (self.num_inputs_annotations,
-                                                            save_path))
+    logger.info("Downloaded %d inputs and %d annotations to %s" %
+                (self.num_inputs, self.num_annotations, save_path))