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

clarifai/client/search.py

@@ -10,7 +10,8 @@ from schema import SchemaError
 from clarifai.client.base import BaseClient
 from clarifai.client.input import Inputs
 from clarifai.client.lister import Lister
-from clarifai.constants.search import DEFAULT_SEARCH_METRIC, DEFAULT_TOP_K
+from clarifai.constants.search import (DEFAULT_SEARCH_ALGORITHM, DEFAULT_SEARCH_METRIC,
+                                       DEFAULT_TOP_K)
 from clarifai.errors import UserError
 from clarifai.schema.search import get_schema
 
@@ -20,8 +21,10 @@ class Search(Lister, BaseClient):
   def __init__(self,
                user_id: str,
                app_id: str,
-               top_k: int = DEFAULT_TOP_K,
+               top_k: int = None,
                metric: str = DEFAULT_SEARCH_METRIC,
+               algorithm: str = DEFAULT_SEARCH_ALGORITHM,
+               pagination: bool = False,
                base_url: str = "https://api.clarifai.com",
                pat: str = None,
                token: str = None,
@@ -33,6 +36,8 @@ class Search(Lister, BaseClient):
         app_id (str): App ID.
         top_k (int, optional): Top K results to retrieve. Defaults to 10.
         metric (str, optional): Similarity metric (either 'cosine' or 'euclidean'). Defaults to 'cosine'.
+        alogrithm (str, optional): Search algorithm (either 'nearest_neighbor' or 'brute_force'). Defaults to 'nearest_neighbor'.
+        pagination (bool, optional): Enable pagination. Defaults to False.
         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
@@ -40,16 +45,27 @@ class Search(Lister, BaseClient):
 
     Raises:
         UserError: If the metric is not 'cosine' or 'euclidean'.
+        UserError: If the algorithm is not 'nearest_neighbor' or 'brute_force'.
     """
     if metric not in ["cosine", "euclidean"]:
       raise UserError("Metric should be either cosine or euclidean")
+    if algorithm not in ["nearest_neighbor", "brute_force"]:
+      raise UserError("Algorithm should be either nearest_neighbor or brute_force")
+    if metric == "cosine" and algorithm == "nearest_neighbor":
+      raise UserError("Cosine distance metric is not supported with nearest neighbor algorithm")
+    if top_k and pagination:
+      raise UserError(
+          "top_k and pagination cannot be used together. Please set pagination to False.")
+    if not top_k and not pagination:
+      top_k = DEFAULT_TOP_K
 
     self.user_id = user_id
     self.app_id = app_id
     self.metric_distance = dict(cosine="COSINE_DISTANCE", euclidean="EUCLIDEAN_DISTANCE")[metric]
+    self.algorithm = algorithm
     self.data_proto = resources_pb2.Data()
     self.top_k = top_k
-
+    self.pagination = pagination
     self.inputs = Inputs(
         user_id=self.user_id, app_id=self.app_id, pat=pat, token=token, base_url=base_url)
     self.rank_filter_schema = get_schema()
@@ -159,9 +175,8 @@ class Search(Lister, BaseClient):
         geo_point=resources_pb2.GeoPoint(longitude=longitude, latitude=latitude),
         geo_limit=resources_pb2.GeoLimit(type="withinKilometers", value=geo_limit))
 
-  def list_all_pages_generator(
-      self, endpoint: Callable[..., Any], proto_message: Any,
-      request_data: Dict[str, Any]) -> Generator[Dict[str, Any], None, None]:
+  def _list_topk_generator(self, endpoint: Callable[..., Any], proto_message: Any,
+                           request_data: Dict[str, Any]) -> Generator[Dict[str, Any], None, None]:
     """Lists all pages of a resource.
 
         Args:
@@ -199,12 +214,61 @@ class Search(Lister, BaseClient):
       total_hits += per_page
       yield response
 
-  def query(self, ranks=[{}], filters=[{}]):
+  def _list_all_pages_generator(self,
+                                endpoint: Callable,
+                                proto_message: Any,
+                                request_data: Dict[str, Any],
+                                page_no: int = None,
+                                per_page: int = None) -> Generator[Dict[str, Any], None, None]:
+    """Lists pages of a resource.
+
+    Args:
+        endpoint (Callable): The endpoint to call.
+        proto_message (Any): The proto message to use.
+        request_data (dict): The request data to use.
+        page_no (int): The page number to list.
+        per_page (int): The number of items per page.
+
+    Yields:
+        response_dict: The next item in the listing.
+    """
+    page = 1 if not page_no else page_no
+    if page_no and not per_page:
+      per_page = self.default_page_size
+    while True:
+      request_data['pagination'] = service_pb2.Pagination(page=page, per_page=per_page)
+      response = self._grpc_request(endpoint, proto_message(**request_data))
+      dict_response = MessageToDict(response, preserving_proto_field_name=True)
+      if response.status.code != status_code_pb2.SUCCESS:
+        if "page * perPage cannot exceed" in str(response.status.details):
+          msg = (f"Your pagination is set to {page_no*per_page}. "
+                 f"The current pagination settings exceed the limit. Please reach out to "
+                 f"support@clarifai.com to request an increase for your use case.\n"
+                 f"req_id: {response.status.req_id}")
+          raise UserError(msg)
+        else:
+          raise Exception(f"Listing failed with response {response!r}")
+      if 'hits' not in list(dict_response.keys()):
+        break
+      yield response
+      if page_no is not None or per_page is not None:
+        break
+      page += 1
+
+  def query(
+      self,
+      ranks=[{}],
+      filters=[{}],
+      page_no: int = None,
+      per_page: int = None,
+  ):
     """Perform a query with rank and filters.
 
     Args:
         ranks (List[Dict], optional): List of rank parameters. Defaults to [{}].
         filters (List[Dict], optional): List of filter parameters. Defaults to [{}].
+        page_no (int): The page number to list.
+        per_page (int): The number of items per page.
 
     Returns:
         Generator[Dict[str, Any], None, None]: A generator of query results.
@@ -217,13 +281,16 @@ class Search(Lister, BaseClient):
 
         Vector search over inputs
         >>> from clarifai.client.search import Search
-        >>> search = Search(user_id='user_id', app_id='app_id', top_k=1, metric='cosine')
-        >>> res = search.query(ranks=[{'image_url': 'https://samples.clarifai.com/dog.tiff'}])
+        >>> search = Search(user_id='user_id', app_id='app_id' , metric='cosine', pagination=True)
+        >>> res = search.query(ranks=[{'image_url': 'https://samples.clarifai.com/dog.tiff'}],page_no=2, per_page=5)
 
     Note:
         For schema of rank and filter, please refer to [schema](https://github.com/Clarifai/clarifai-python/tree/master/clarifai/schema/search.py).
         For more detailed search examples, please refer to [examples](https://github.com/Clarifai/examples/tree/main/search).
     """
+    if not self.pagination and (per_page or page_no):
+      raise UserError("Pagination settings are only available when pagination is enabled."
+                      "Please set Search(pagination=True) while initializing Search().")
     try:
       self.rank_filter_schema.validate(ranks)
       self.rank_filter_schema.validate(filters)
@@ -249,11 +316,15 @@ class Search(Lister, BaseClient):
           searches=[
               resources_pb2.Search(
                   query=resources_pb2.Query(ranks=all_ranks, filters=all_filters),
+                  algorithm=self.algorithm,
                   metric=self.metric_distance)
           ])
-
-      return self.list_all_pages_generator(self.STUB.PostInputsSearches,
-                                           service_pb2.PostInputsSearchesRequest, request_data)
+      if self.pagination:
+        return self._list_all_pages_generator(self.STUB.PostInputsSearches,
+                                              service_pb2.PostInputsSearchesRequest, request_data,
+                                              page_no, per_page)
+      return self._list_topk_generator(self.STUB.PostInputsSearches,
+                                       service_pb2.PostInputsSearchesRequest, request_data)
 
     # Calls PostAnnotationsSearches for annotation ranks, filters
     filters_annot_proto = []
@@ -269,8 +340,12 @@ class Search(Lister, BaseClient):
         searches=[
             resources_pb2.Search(
                 query=resources_pb2.Query(ranks=all_ranks, filters=all_filters),
+                algorithm=self.algorithm,
                 metric=self.metric_distance)
         ])
-
-    return self.list_all_pages_generator(self.STUB.PostAnnotationsSearches,
-                                         service_pb2.PostAnnotationsSearchesRequest, request_data)
+    if self.pagination:
+      return self._list_all_pages_generator(self.STUB.PostAnnotationsSearches,
+                                            service_pb2.PostAnnotationsSearchesRequest,
+                                            request_data, page_no, per_page)
+    return self._list_topk_generator(self.STUB.PostAnnotationsSearches,
+                                     service_pb2.PostAnnotationsSearchesRequest, request_data)

clarifai/constants/model.py

@@ -3,3 +3,4 @@ TRAINABLE_MODEL_TYPES = [
     'text-classifier', 'embedding-classifier', 'text-to-text'
 ]
 MAX_MODEL_PREDICT_INPUTS = 128
+MODEL_EXPORT_TIMEOUT = 1800

clarifai/constants/search.py

@@ -1,2 +1,3 @@
 DEFAULT_TOP_K = 10
-DEFAULT_SEARCH_METRIC = "cosine"
+DEFAULT_SEARCH_METRIC = "euclidean"
+DEFAULT_SEARCH_ALGORITHM = "nearest_neighbor"

clarifai/datasets/upload/features.py

@@ -10,6 +10,7 @@ class TextFeatures:
   labels: List[Union[str, int]]  # List[str or int] to cater for multi-class tasks
   id: Optional[int] = None  # text_id
   metadata: Optional[dict] = None
+  label_ids: Optional[List[str]] = None
 
 
 @dataclass
@@ -21,6 +22,7 @@ class VisualClassificationFeatures:
   id: Optional[int] = None  # image_id
   metadata: Optional[dict] = None
   image_bytes: Optional[bytes] = None
+  label_ids: Optional[List[str]] = None
 
 
 @dataclass
@@ -33,6 +35,7 @@ class VisualDetectionFeatures:
   id: Optional[int] = None  # image_id
   metadata: Optional[dict] = None
   image_bytes: Optional[bytes] = None
+  label_ids: Optional[List[str]] = None
 
 
 @dataclass
@@ -45,3 +48,4 @@ class VisualSegmentationFeatures:
   id: Optional[int] = None  # image_id
   metadata: Optional[dict] = None
   image_bytes: Optional[bytes] = None
+  label_ids: Optional[List[str]] = None

clarifai/datasets/upload/image.py

@@ -32,6 +32,7 @@ class VisualClassificationDataset(ClarifaiDataset):
       image_path = data_item.image_path
       labels = data_item.labels if isinstance(data_item.labels,
                                               list) else [data_item.labels]  # clarifai concept
+      label_ids = data_item.label_ids
       input_id = f"{self.dataset_id}-{uuid.uuid4().hex[:8]}" if data_item.id is None else f"{self.dataset_id}-{str(data_item.id)}"
       geo_info = data_item.geo_info
       if data_item.metadata is not None:
@@ -49,6 +50,7 @@ class VisualClassificationDataset(ClarifaiDataset):
                 image_bytes=data_item.image_bytes,
                 dataset_id=self.dataset_id,
                 labels=labels,
+                label_ids=label_ids,
                 geo_info=geo_info,
                 metadata=metadata))
       else:
@@ -58,6 +60,7 @@ class VisualClassificationDataset(ClarifaiDataset):
                 image_file=image_path,
                 dataset_id=self.dataset_id,
                 labels=labels,
+                label_ids=label_ids,
                 geo_info=geo_info,
                 metadata=metadata))
 
@@ -91,6 +94,12 @@ class VisualDetectionDataset(ClarifaiDataset):
       metadata = Struct()
       image = data_item.image_path
       labels = data_item.labels  # list:[l1,...,ln]
+      if data_item.label_ids is not None:
+        assert len(labels) == len(
+            data_item.label_ids), "Length of labels and label_ids must be equal"
+        label_ids = data_item.label_ids
+      else:
+        label_ids = None
       bboxes = data_item.bboxes  # [[xmin,ymin,xmax,ymax],...,[xmin,ymin,xmax,ymax]]
       input_id = f"{self.dataset_id}-{uuid.uuid4().hex[:8]}" if data_item.id is None else f"{self.dataset_id}-{str(data_item.id)}"
       if data_item.metadata is not None:
@@ -120,7 +129,11 @@ class VisualDetectionDataset(ClarifaiDataset):
       # one id could have more than one bbox and label
       for i in range(len(bboxes)):
         annotation_protos.append(
-            Inputs.get_bbox_proto(input_id=input_id, label=labels[i], bbox=bboxes[i]))
+            Inputs.get_bbox_proto(
+                input_id=input_id,
+                label=labels[i],
+                bbox=bboxes[i],
+                label_id=label_ids[i] if label_ids else None))
 
     with ThreadPoolExecutor(max_workers=4) as executor:
       futures = [executor.submit(process_data_item, id) for id in batch_input_ids]
@@ -152,6 +165,12 @@ class VisualSegmentationDataset(ClarifaiDataset):
       metadata = Struct()
       image = data_item.image_path
       labels = data_item.labels
+      if data_item.label_ids is not None:
+        assert len(labels) == len(
+            data_item.label_ids), "Length of labels and label_ids must be equal"
+        label_ids = data_item.label_ids
+      else:
+        label_ids = None
       _polygons = data_item.polygons  # list of polygons: [[[x,y],...,[x,y]],...]
       input_id = f"{self.dataset_id}-{uuid.uuid4().hex[:8]}" if data_item.id is None else f"{self.dataset_id}-{str(data_item.id)}"
       if data_item.metadata is not None:
@@ -183,7 +202,11 @@ class VisualSegmentationDataset(ClarifaiDataset):
       for i, _polygon in enumerate(_polygons):
         try:
           annotation_protos.append(
-              Inputs.get_mask_proto(input_id=input_id, label=labels[i], polygons=_polygon))
+              Inputs.get_mask_proto(
+                  input_id=input_id,
+                  label=labels[i],
+                  polygons=_polygon,
+                  label_id=label_ids[i] if label_ids else None))
         except IndexError:
           continue
 

clarifai/datasets/upload/loaders/coco_captions.py

@@ -2,12 +2,17 @@
 
 import os
 
-from pycocotools.coco import COCO
-
 from clarifai.datasets.upload.base import ClarifaiDataLoader
 
 from ..features import VisualClassificationFeatures
 
+#pycocotools is a dependency for this loader
+try:
+  from pycocotools.coco import COCO
+except ImportError:
+  raise ImportError("Could not import pycocotools package. "
+                    "Please do `pip install 'clarifai[all]'` to import pycocotools.")
+
 
 class COCOCaptionsDataLoader(ClarifaiDataLoader):
   """COCO Image Captioning Dataset."""

clarifai/datasets/upload/loaders/coco_detection.py

@@ -2,12 +2,17 @@
 
 import os
 
-from pycocotools.coco import COCO
-
 from ..base import ClarifaiDataLoader
 
 from ..features import VisualDetectionFeatures
 
+#pycocotools is a dependency for this loader
+try:
+  from pycocotools.coco import COCO
+except ImportError:
+  raise ImportError("Could not import pycocotools package. "
+                    "Please do `pip install 'clarifai[all]'` to import pycocotools.")
+
 
 class COCODetectionDataLoader(ClarifaiDataLoader):
 

clarifai/datasets/upload/text.py

@@ -32,6 +32,7 @@ class TextClassificationDataset(ClarifaiDataset):
       text = data_item.text
       labels = data_item.labels if isinstance(data_item.labels,
                                               list) else [data_item.labels]  # clarifai concept
+      label_ids = data_item.label_ids
       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)
@@ -43,6 +44,7 @@ class TextClassificationDataset(ClarifaiDataset):
               raw_text=text,
               dataset_id=self.dataset_id,
               labels=labels,
+              label_ids=label_ids,
               metadata=metadata))
 
     with ThreadPoolExecutor(max_workers=4) as executor:

clarifai/models/model_serving/README.md

@@ -141,6 +141,9 @@ Get your PAT from https://clarifai.com/settings/security and pass it here: <inse
 Upload
 
 ```bash
+# upload built file directly
+$ clarifai upload model <your-working-dir> --user-app <your_user_id>/<your_app_id> --id <your_model_id>
+# or using direct download url of cloud storage
 $ clarifai upload model --url <url> --user-app <your_user_id>/<your_app_id> --id <your_model_id>
 ```
 

clarifai/models/model_serving/cli/upload.py

@@ -14,14 +14,11 @@
 import argparse
 import os
 import subprocess
-from typing import Union
 
-from clarifai.client.auth.helper import ClarifaiAuthHelper
-from clarifai.models.api import Models
-from clarifai.models.model_serving.model_config import (MODEL_TYPES, get_model_config,
-                                                        load_user_config)
+from clarifai.models.model_serving.model_config import get_model_config, load_user_config
 from clarifai.models.model_serving.model_config.inference_parameter import InferParamManager
 
+from ..constants import BUILT_MODEL_EXT
 from ..utils import login
 from .base import BaseClarifaiCli
 
@@ -51,7 +48,9 @@ class UploadModelSubCli(BaseClarifaiCli):
         "Path to working dir to get clarifai_config.yaml or path to yaml. Default is current directory",
         default=".")
     upload_parser.add_argument(
-        "--url", type=str, required=True, help="Direct download url of zip file")
+        "--url", type=str, required=False, help="Direct download url of zip file", default=None)
+    upload_parser.add_argument(
+        "--file", type=str, required=False, help="Local built file", default=None)
     upload_parser.add_argument("--id", type=str, required=False, help="Model ID")
     upload_parser.add_argument(
         "--user-app",
@@ -62,7 +61,10 @@ class UploadModelSubCli(BaseClarifaiCli):
         "--no-test",
         action="store_true",
         help="Trigger this flag to skip testing before uploading")
-
+    upload_parser.add_argument(
+        "--no-resume",
+        action="store_true",
+        help="Trigger this flag to not resume uploading local file")
     upload_parser.add_argument(
         "--update-version",
         action="store_true",
@@ -73,10 +75,13 @@ class UploadModelSubCli(BaseClarifaiCli):
 
   def __init__(self, args: argparse.Namespace) -> None:
     self.no_test = args.no_test
+    self.no_resume = args.no_resume
 
     working_dir_or_config = args.path
     # if input a config file, then not running test
     if working_dir_or_config.endswith(".yaml"):
+      # to folder
+      working_dir_or_config = os.path.split(working_dir_or_config)[0]
       config_yaml_path = working_dir_or_config
       self.test_path = None
       self.no_test = True
@@ -89,12 +94,27 @@ class UploadModelSubCli(BaseClarifaiCli):
         f"`{config_yaml_path}` does not exist")
     self.config = load_user_config(cfg_path=config_yaml_path)
 
+    self.file = args.file
+    self.url = args.url
+    if self.file:
+      assert self.url, ValueError("Provide either file or url, but got 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}"
+      self.file = None
+    else:
+      for _fname in os.listdir(working_dir_or_config):
+        if _fname.endswith(BUILT_MODEL_EXT):
+          self.file = os.path.join(working_dir_or_config, _fname)
+          break
+      assert self.file, ValueError(
+          f"Not using url/file but also not found built file with extension {BUILT_MODEL_EXT}")
+
     self.user_id, self.app_id = "", ""
     user_app = args.user_app
     self.url: str = args.url
     self.update_version = args.update_version
-    assert self.url.startswith("http") or self.url.startswith(
-        "s3"), f"Invalid url supported http or s3 url. Got {self.url}"
 
     clarifai_cfg = self.config.clarifai_model
     self.url: str = args.url
@@ -111,17 +131,10 @@ class UploadModelSubCli(BaseClarifaiCli):
       ) == 2, f"id must be combination of user_id and app_id separated by `/`, e.g. <user_id>/<app_id>. Got {args.id}"
       self.user_id, self.app_id = user_app
 
-    if self.user_id:
-      os.environ["CLARIFAI_USER_ID"] = self.user_id
-    if self.app_id:
-      os.environ["CLARIFAI_APP_ID"] = self.app_id
-
-    _user_id = os.environ.get("CLARIFAI_USER_ID", None)
-    _app_id = os.environ.get("CLARIFAI_APP_ID", None)
-    assert _user_id or _app_id, f"Missing user-id or app-id, got user-id {_user_id} and app-id {_app_id}"
     login()
 
   def run(self):
+    from clarifai.client import App, Model
 
     # Run test before uploading
     if not self.no_test:
@@ -129,54 +142,38 @@ class UploadModelSubCli(BaseClarifaiCli):
       result = subprocess.run(f"pytest -s --log-level=INFO {self.test_path}", shell=True)
       assert result.returncode == 0, "Test has failed. Please make sure no error exists in your code."
 
-    deploy(
-        model_url=self.url,
-        model_id=self.id,
-        desc=self.desc,
-        model_type=self.type,
-        update_version=self.update_version,
-        inference_parameters=self.infer_param)
-
-
-def deploy(model_url,
-           model_id: str = None,
-           model_type: str = None,
-           desc: str = "",
-           update_version: bool = False,
-           inference_parameters: Union[dict, str] = None):
-  # init Auth from env vars
-  auth = ClarifaiAuthHelper.from_env()
-  # init api
-  model_api = Models(auth)
-  # key map
-  assert model_type in MODEL_TYPES, f"model_type should be one of {MODEL_TYPES}"
-  clarifai_key_map = get_model_config(model_type=model_type).clarifai_model.field_maps
-  # inference parameters
-  if isinstance(inference_parameters, str) and os.path.isfile(inference_parameters):
-    inference_parameters = InferParamManager(json_path=inference_parameters).get_list_params()
-  # if updating new version of existing model
-  if update_version:
-    resp = model_api.post_model_version(
-        model_id=model_id,
-        model_zip_url=model_url,
-        input=clarifai_key_map.input_fields_map,
-        outputs=clarifai_key_map.output_fields_map,
-        param_specs=inference_parameters)
-  # creating new model
-  else:
-    # post model
-    resp = model_api.upload_model(
-        model_id=model_id,
-        model_zip_url=model_url,
-        model_type=model_type,
-        input=clarifai_key_map.input_fields_map,
-        outputs=clarifai_key_map.output_fields_map,
-        description=desc,
-        param_specs=inference_parameters)
-  # response
-  if resp["status"]["code"] != "SUCCESS":
-    raise Exception("Post models failed, details: {}, {}".format(resp["status"]["description"],
-                                                                 resp["status"]["details"]))
-  else:
-    print("Success!")
-    print(f'Model version: {resp["model"]["model_version"]["id"]}')
+    clarifai_key_map = get_model_config(model_type=self.type).clarifai_model.field_maps
+    # inference parameters
+    inference_parameters = None
+    if isinstance(self.infer_param, str) and os.path.isfile(self.infer_param):
+      inference_parameters = InferParamManager(json_path=self.infer_param).get_list_params()
+    inputs = clarifai_key_map.input_fields_map
+    outputs = clarifai_key_map.output_fields_map
+
+    # if updating new version of existing model
+    def update_version():
+      model = Model(model_id=self.id, app_id=self.app_id)
+      if self.url:
+        model.create_version_by_url(
+            url=self.url,
+            input_field_maps=inputs,
+            output_field_maps=outputs,
+            inference_parameter_configs=inference_parameters,
+            description=self.desc)
+      elif self.file:
+        model.create_version_by_file(
+            file_path=self.file,
+            input_field_maps=inputs,
+            output_field_maps=outputs,
+            inference_parameter_configs=inference_parameters,
+            no_resume=self.no_resume,
+            description=self.desc)
+      else:
+        raise ValueError
+
+    if self.update_version:
+      update_version()
+    else:
+      # creating new model
+      _ = App(app_id=self.app_id).create_model(self.id, model_type_id=self.type)
+      update_version()

clarifai/models/model_serving/docs/cli.md

@@ -127,7 +127,15 @@ optional arguments:
 
 5. Upload
 
-This step will run `test.py` in provided working dir as default before building
+This step will execute test.py in the specified working directory by default before proceeding with the build. You can upload your built file directly from the working directory to the platform or upload it to cloud storage and provide the direct URL during the upload process.
+
+Use the following command to upload your built file directly to the platform. It will upload the `*.clarifai` file. *Note*: Only support file size from 5MiB to 5GiB
+
+```bash
+$ clarifai upload model <your_working_dir>
+```
+
+or upload with direct download url
 
 ```bash
 $ clarifai upload model <your_working_dir> --url <your url>
@@ -141,10 +149,13 @@ positional arguments:
   path                  Path to working dir to get clarifai_config.yaml or path to yaml. Default is current directory
 
 optional arguments:
-  --url                 Direct download url of zip file
-  --id                  Model ID
-  --user-app            User ID and App ID separated by '/', e.g., <user_id>/<app_id>
-  --update-version      Update exist model with new version
-  --no-test             Trigger this flag to skip testing before uploading
+  -h, --help           show this help message and exit
+  --url URL            Direct download url of zip file
+  --file FILE          Local built file
+  --id ID              Model ID
+  --user-app USER_APP  User ID and App ID separated by '/', e.g., <user_id>/<app_id>
+  --no-test            Trigger this flag to skip testing before uploading
+  --no-resume          Trigger this flag to not resume uploading local file
+  --update-version     Update exist model with new version
 
 ```

clarifai/rag/rag.py

@@ -110,7 +110,7 @@ class RAG:
     prompter_model_params = {"params": params}
 
     ## Create rag-prompter model and version
-    model_id = f"prompter-{workflow_id}" if workflow_id is not None else f"rag-prompter-{now_ts}"
+    model_id = f"prompter-{workflow_id}-{now_ts}" if workflow_id is not None else f"rag-prompter-{now_ts}"
     prompter_model = app.create_model(model_id=model_id, model_type_id="rag-prompter")
     prompter_model = prompter_model.create_version(output_info=prompter_model_params)
 

clarifai/rag/utils.py

@@ -67,7 +67,7 @@ def load_documents(file_path: str = None, folder_path: str = None, url: str = No
   #document loaders for folderpath
   if folder_path:
     documents = SimpleDirectoryReader(
-        input_dir=Path(folder_path), required_exts=[".pdf", ".docx"]).load_data()
+        input_dir=Path(folder_path), required_exts=[".pdf", ".docx", ".txt"]).load_data()
 
   #document loaders for url
   if url:
@@ -111,7 +111,7 @@ def split_document(text: str, chunk_size: int, chunk_overlap: int, **kwargs) ->
     from llama_index.core.node_parser.text import SentenceSplitter
   except ImportError:
     raise ImportError("Could not import llama index package. "
-                      "Please install it with `pip install llama-index-core==0.10.1`.")
+                      "Please install it with `pip install llama-index-core==0.10.24`.")
   #document
   text_parser = SentenceSplitter(chunk_size=chunk_size, chunk_overlap=chunk_overlap, **kwargs)
   text_chunks = text_parser.split_text(text)

clarifai/versions.py

@@ -1,6 +1,6 @@
 import os
 
-CLIENT_VERSION = "10.3.0"
+CLIENT_VERSION = "10.3.2"
 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]))