clarifai 10.2.1__py3-none-any.whl → 10.3.1__py3-none-any.whl

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

@@ -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,11 +21,14 @@ 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):
+               token: str = None,
+               root_certificates_path: str = None):
     """Initialize the Search object.
 
     Args:
@@ -32,27 +36,47 @@ 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
+        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'.
+        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()
     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):
@@ -151,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:
@@ -191,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.
@@ -209,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)
@@ -241,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 = []
@@ -261,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/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):

clarifai/constants/input.py

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

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/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: