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

clarifai/client/input.py

@@ -72,6 +72,7 @@ class Inputs(Lister, BaseClient):
                  text_pb: Text = None,
                  geo_info: List = None,
                  labels: List = None,
+                 label_ids: List = None,
                  metadata: Struct = None) -> Input:
     """Create input proto for image data type.
         Args:
@@ -82,7 +83,8 @@ class Inputs(Lister, BaseClient):
             audio_pb (Audio): The audio proto to be used for the input.
             text_pb (Text): The text proto to be used for the input.
             geo_info (list): A list of longitude and latitude for the geo point.
-            labels (list): A list of labels for the input.
+            labels (list): A list of label names for the input.
+            label_ids (list): A list of label ids for the input.
             metadata (Struct): A Struct of metadata for the input.
         Returns:
             Input: An Input object for the specified input ID.
@@ -90,14 +92,26 @@ class Inputs(Lister, BaseClient):
     assert geo_info is None or isinstance(
         geo_info, list), "geo_info must be a list of longitude and latitude"
     assert labels is None or isinstance(labels, list), "labels must be a list of strings"
+    assert label_ids is None or isinstance(label_ids, list), "label_ids must be a list of strings"
     assert metadata is None or isinstance(metadata, Struct), "metadata must be a Struct"
     geo_pb = resources_pb2.Geo(geo_point=resources_pb2.GeoPoint(
         longitude=geo_info[0], latitude=geo_info[1])) if geo_info else None
-    concepts=[
+    if labels:
+      if not label_ids:
+        concepts=[
             resources_pb2.Concept(
             id=f"id-{''.join(_label.split(' '))}", name=_label, value=1.)\
             for _label in labels
-        ]if labels else None
+        ]
+      else:
+        assert len(labels) == len(label_ids), "labels and label_ids must be of the same length"
+        concepts=[
+            resources_pb2.Concept(
+            id=label_id, name=_label, value=1.)\
+            for label_id, _label in zip(label_ids, labels)
+        ]
+    else:
+      concepts = None
 
     if dataset_id:
       return resources_pb2.Input(
@@ -467,13 +481,14 @@ class Inputs(Lister, BaseClient):
     return input_protos
 
   @staticmethod
-  def get_bbox_proto(input_id: str, label: str, bbox: List) -> Annotation:
+  def get_bbox_proto(input_id: str, label: str, bbox: List, label_id: str = None) -> Annotation:
     """Create an annotation proto for each bounding box, label input pair.
 
     Args:
         input_id (str): The input ID for the annotation to create.
-        label (str): annotation label
+        label (str): annotation label name
         bbox (List): a list of a single bbox's coordinates. # bbox ordering: [xmin, ymin, xmax, ymax]
+        label_id (str): annotation label ID
 
     Returns:
         An annotation object for the specified input ID.
@@ -500,19 +515,22 @@ class Inputs(Lister, BaseClient):
                 data=resources_pb2.Data(concepts=[
                     resources_pb2.Concept(
                         id=f"id-{''.join(label.split(' '))}", name=label, value=1.)
+                    if not label_id else resources_pb2.Concept(id=label_id, name=label, value=1.)
                 ]))
         ]))
 
     return input_annot_proto
 
   @staticmethod
-  def get_mask_proto(input_id: str, label: str, polygons: List[List[float]]) -> Annotation:
+  def get_mask_proto(input_id: str, label: str, polygons: List[List[float]],
+                     label_id: str = None) -> Annotation:
     """Create an annotation proto for each polygon box, label input pair.
 
     Args:
         input_id (str): The input ID for the annotation to create.
-        label (str): annotation label
+        label (str): annotation label name
         polygons (List): Polygon x,y points iterable
+        label_id (str): annotation label ID
 
     Returns:
         An annotation object for the specified input ID.
@@ -537,6 +555,7 @@ class Inputs(Lister, BaseClient):
                 data=resources_pb2.Data(concepts=[
                     resources_pb2.Concept(
                         id=f"id-{''.join(label.split(' '))}", name=label, value=1.)
+                    if not label_id else resources_pb2.Concept(id=label_id, name=label, value=1.)
                 ]))
         ]))
 
@@ -726,16 +745,20 @@ class Inputs(Lister, BaseClient):
     request = service_pb2.PostAnnotationsRequest(
         user_app_id=self.user_app_id, annotations=batch_annot)
     response = self._grpc_request(self.STUB.PostAnnotations, request)
+    response_dict = MessageToDict(response)
     if response.status.code != status_code_pb2.SUCCESS:
       try:
-        self.logger.warning(f"Post annotations failed, status: {response.annotations[0].status}")
+        for annot in response_dict["annotations"]:
+          if annot['status']['code'] != status_code_pb2.ANNOTATION_SUCCESS:
+            self.logger.warning(f"Post annotations failed, status: {annot['status']}")
       except Exception:
-        self.logger.warning(f"Post annotations failed, status: {response.status.details}")
+        self.logger.warning(f"Post annotations failed due to {response.status}")
       finally:
         retry_upload.extend(batch_annot)
     else:
       if show_log:
         self.logger.info("\nAnnotations Uploaded\n%s", response.status)
+
     return retry_upload
 
   def _upload_batch(self, inputs: List[Input]) -> List[Input]:

clarifai/client/model.py

@@ -1,3 +1,4 @@
+import json
 import os
 import time
 from typing import Any, Dict, Generator, List, Tuple, Union
@@ -9,14 +10,15 @@ from clarifai_grpc.grpc.api import resources_pb2, service_pb2
 from clarifai_grpc.grpc.api.resources_pb2 import Input
 from clarifai_grpc.grpc.api.status import status_code_pb2
 from google.protobuf.json_format import MessageToDict
-from google.protobuf.struct_pb2 import Struct
+from google.protobuf.struct_pb2 import Struct, Value
 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
+from clarifai.constants.model import (MAX_MODEL_PREDICT_INPUTS, MODEL_EXPORT_TIMEOUT,
+                                      TRAINABLE_MODEL_TYPES)
 from clarifai.errors import UserError
 from clarifai.urls.helper import ClarifaiUrlHelper
 from clarifai.utils.logging import get_logger
@@ -25,6 +27,10 @@ from clarifai.utils.model_train import (find_and_replace_key, params_parser,
                                         response_to_model_params, response_to_param_info,
                                         response_to_templates)
 
+MAX_SIZE_PER_STREAM = int(89_128_960)  # 85GiB
+MIN_CHUNK_FOR_UPLOAD_FILE = int(5_242_880)  # 5MiB
+MAX_CHUNK_FOR_UPLOAD_FILE = int(5_242_880_000)  # 5GiB
+
 
 class Model(Lister, BaseClient):
   """Model is a class that provides access to Clarifai API endpoints related to Model information."""
@@ -58,7 +64,7 @@ class Model(Lister, BaseClient):
       user_id, app_id, _, model_id, model_version_id = ClarifaiUrlHelper.split_clarifai_url(url)
       model_version = {'id': model_version_id}
       kwargs = {'user_id': user_id, 'app_id': app_id}
-    self.kwargs = {**kwargs, 'id': model_id, 'model_version': model_version,}
+    self.kwargs = {**kwargs, 'id': model_id, 'model_version': model_version, }
     self.model_info = resources_pb2.Model(**self.kwargs)
     self.logger = get_logger(logger_level="INFO", name=__name__)
     self.training_params = {}
@@ -132,11 +138,11 @@ class Model(Lister, BaseClient):
       raise Exception(response.status)
     params = response_to_model_params(
         response=response, model_type_id=self.model_info.model_type_id, template=template)
-    #yaml file
+    # yaml file
     assert save_to.endswith('.yaml'), "File extension should be .yaml"
     with open(save_to, 'w') as f:
       yaml.dump(params, f, default_flow_style=False, sort_keys=False)
-    #updating the global model params
+    # updating the global model params
     self.training_params.update(params)
 
     return params
@@ -159,14 +165,14 @@ class Model(Lister, BaseClient):
       raise UserError(
           f"Run 'model.get_params' to get the params for the {self.model_info.model_type_id} model type"
       )
-    #getting all the keys in nested dictionary
+    # getting all the keys in nested dictionary
     all_keys = [key for key in self.training_params.keys()] + [
         key for key in self.training_params.values() if isinstance(key, dict) for key in key
     ]
-    #checking if the given params are valid
+    # checking if the given params are valid
     if not set(kwargs.keys()).issubset(all_keys):
       raise UserError("Invalid params")
-    #updating the global model params
+    # updating the global model params
     for key, value in kwargs.items():
       find_and_replace_key(self.training_params, key, value)
 
@@ -238,7 +244,7 @@ class Model(Lister, BaseClient):
         params_dict = yaml.safe_load(file)
     else:
       params_dict = self.training_params
-    #getting all the concepts for the model type
+    # getting all the concepts for the model type
     if self.model_info.model_type_id not in ["clusterer", "text-to-text"]:
       concepts = self._list_concepts()
     train_dict = params_parser(params_dict, concepts)
@@ -423,7 +429,7 @@ class Model(Lister, BaseClient):
       response = self._grpc_request(self.STUB.PostModelOutputs, request)
 
       if response.status.code == status_code_pb2.MODEL_DEPLOYING and \
-        time.time() - start_time < 60 * 10: # 10 minutes
+              time.time() - start_time < 60 * 10:  # 10 minutes
         self.logger.info(f"{self.id} model is still deploying, please wait...")
         time.sleep(next(backoff_iterator))
         continue
@@ -944,19 +950,22 @@ class Model(Lister, BaseClient):
     """Export the model, stores the exported model as model.tar file
 
     Args:
-        export_dir (str): The directory to save the exported model.
+        export_dir (str, optional): If provided, the exported model will be saved in the specified directory else export status will be shown. Defaults to None.
 
     Example:
         >>> from clarifai.client.model import Model
         >>> model = Model("url")
+        >>> model.export()
+                or
         >>> model.export('/path/to/export_model_dir')
     """
     assert self.model_info.model_version.id, "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."
-    try:
-      if not os.path.exists(export_dir):
-        os.makedirs(export_dir)
-    except OSError as e:
-      raise Exception(f"An error occurred while creating the directory: {e}")
+    if export_dir:
+      try:
+        if not os.path.exists(export_dir):
+          os.makedirs(export_dir)
+      except OSError as e:
+        raise Exception(f"An error occurred while creating the directory: {e}")
 
     def _get_export_response():
       get_export_request = service_pb2.GetModelVersionExportRequest(
@@ -1005,25 +1014,335 @@ class Model(Lister, BaseClient):
         raise Exception(response.status)
 
       self.logger.info(
-          f"Model ID {self.id} with version {self.model_info.model_version.id} export started, please wait..."
+          f"Export process has started for Model ID {self.id}, Version {self.model_info.model_version.id}"
       )
-      time.sleep(5)
-      start_time = time.time()
-      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 \
-          time.time() - start_time < 60 * 30: # 30 minutes
-          self.logger.info(
-              f"Model ID {self.id} with version {self.model_info.model_version.id} is still exporting, please wait..."
-          )
-          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
-              Req ID: {get_export_response.status.req_id}""")
+      if export_dir:
+        start_time = time.time()
+        backoff_iterator = BackoffIterator(10)
+        while True:
+          get_export_response = _get_export_response()
+          if (get_export_response.export.status.code == status_code_pb2.MODEL_EXPORTING or \
+                get_export_response.export.status.code == status_code_pb2.MODEL_EXPORT_PENDING) and \
+                  time.time() - start_time < MODEL_EXPORT_TIMEOUT:
+            self.logger.info(
+                f"Export process is ongoing for Model ID {self.id}, Version {self.model_info.model_version.id}. Please wait..."
+            )
+            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 > MODEL_EXPORT_TIMEOUT:
+            raise Exception(
+                f"""Model Export took too long. Please try again or contact support@clarifai.com
+                Req ID: {get_export_response.status.req_id}""")
     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"))
+      if export_dir:
+        _download_exported_model(get_export_response, os.path.join(export_dir, "model.tar"))
+      else:
+        self.logger.info(
+            f"Model ID {self.id} with version {self.model_info.model_version.id} is already exported, you can download it from the following URL: {get_export_response.export.url}"
+        )
+    elif get_export_response.export.status.code == status_code_pb2.MODEL_EXPORTING or \
+            get_export_response.export.status.code == status_code_pb2.MODEL_EXPORT_PENDING:
+      self.logger.info(
+          f"Export process is ongoing for Model ID {self.id}, Version {self.model_info.model_version.id}. Please wait..."
+      )
+
+  @staticmethod
+  def _make_pretrained_config_proto(input_field_maps: dict,
+                                    output_field_maps: dict,
+                                    url: str = None):
+    """Make PretrainedModelConfig for uploading new version
+
+    Args:
+        input_field_maps (dict): dict
+        output_field_maps (dict): dict
+        url (str, optional): direct download url. Defaults to None.
+    """
+
+    def _parse_fields_map(x):
+      """parse input, outputs to Struct"""
+      _fields_map = Struct()
+      _fields_map.update(x)
+      return _fields_map
+
+    input_fields_map = _parse_fields_map(input_field_maps)
+    output_fields_map = _parse_fields_map(output_field_maps)
+
+    return resources_pb2.PretrainedModelConfig(
+        input_fields_map=input_fields_map, output_fields_map=output_fields_map, model_zip_url=url)
+
+  @staticmethod
+  def _make_inference_params_proto(
+      inference_parameters: List[Dict]) -> List[resources_pb2.ModelTypeField]:
+    """Convert list of Clarifai inference parameters to proto for uploading new version
+
+    Args:
+        inference_parameters (List[Dict]): Each dict has keys {field_type, path, default_value, description}
+
+    Returns:
+        List[resources_pb2.ModelTypeField]
+    """
+
+    def _make_default_value_proto(dtype, value):
+      if dtype == 1:
+        return Value(bool_value=value)
+      elif dtype == 2 or dtype == 21:
+        return Value(string_value=value)
+      elif dtype == 3:
+        return Value(number_value=value)
+
+    iterative_proto_params = []
+    for param in inference_parameters:
+      dtype = param.get("field_type")
+      proto_param = resources_pb2.ModelTypeField(
+          path=param.get("path"),
+          field_type=dtype,
+          default_value=_make_default_value_proto(dtype=dtype, value=param.get("default_value")),
+          description=param.get("description"),
+      )
+      iterative_proto_params.append(proto_param)
+    return iterative_proto_params
+
+  def create_version_by_file(self,
+                             file_path: str,
+                             input_field_maps: dict,
+                             output_field_maps: dict,
+                             inference_parameter_configs: dict = None,
+                             model_version: str = None,
+                             part_id: int = 1,
+                             range_start: int = 0,
+                             no_cache: bool = False,
+                             no_resume: bool = False,
+                             description: str = "") -> 'Model':
+    """Create model version by uploading local file
+
+    Args:
+        file_path (str): path to built file.
+        input_field_maps (dict): a dict where the key is clarifai input field and the value is triton model input,
+          {clarifai_input_field: triton_input_filed}.
+        output_field_maps (dict): a dict where the keys are clarifai output fields and the values are triton model outputs,
+          {clarifai_output_field1: triton_output_filed1, clarifai_output_field2: triton_output_filed2,...}.
+        inference_parameter_configs (List[dict]): list of dicts - keys are path, field_type, default_value, description. Default is None
+        model_version (str, optional): Custom model version. Defaults to None.
+        part_id (int, optional): part id of file. Defaults to 1.
+        range_start (int, optional): range of uploaded size. Defaults to 0.
+        no_cache (bool, optional): not saving uploading cache that is used to resume uploading. Defaults to False.
+        no_resume (bool, optional): disable auto resume upload. Defaults to False.
+        description (str): Model description.
+
+    Return:
+      Model: instance of Model with new created version
+
+    """
+    file_size = os.path.getsize(file_path)
+    assert MIN_CHUNK_FOR_UPLOAD_FILE <= file_size <= MAX_CHUNK_FOR_UPLOAD_FILE, "The file size exceeds the allowable limit, which ranges from 5MiB to 5GiB."
+
+    pretrained_proto = Model._make_pretrained_config_proto(
+        input_field_maps=input_field_maps, output_field_maps=output_field_maps)
+    inference_param_proto = Model._make_inference_params_proto(
+        inference_parameter_configs) if inference_parameter_configs else None
+
+    if file_size >= 1e9:
+      chunk_size = 1024 * 50_000  # 50MB
+    else:
+      chunk_size = 1024 * 10_000  # 10MB
+
+    #self.logger.info(f"Chunk {chunk_size/1e6}MB, {file_size/chunk_size} steps")
+    #self.logger.info(f" Max bytes per stream {MAX_SIZE_PER_STREAM}")
+
+    cache_dir = os.path.join(file_path, '..', '.cache')
+    cache_upload_file = os.path.join(cache_dir, "upload.json")
+    last_percent = 0
+    if os.path.exists(cache_upload_file) and not no_resume:
+      with open(cache_upload_file, "r") as fp:
+        try:
+          cache_info = json.load(fp)
+          if isinstance(cache_info, dict):
+            part_id = cache_info.get("part_id", part_id)
+            chunk_size = cache_info.get("chunk_size", chunk_size)
+            range_start = cache_info.get("range_start", range_start)
+            model_version = cache_info.get("model_version", model_version)
+            last_percent = cache_info.get("last_percent", last_percent)
+        except Exception as e:
+          self.logger.error(f"Skipping loading the upload cache due to error {e}.")
+
+    def init_model_version_upload(model_version):
+      return service_pb2.PostModelVersionsUploadRequest(
+          upload_config=service_pb2.PostModelVersionsUploadConfig(
+              user_app_id=self.user_app_id,
+              model_id=self.id,
+              total_size=file_size,
+              model_version=resources_pb2.ModelVersion(
+                  id=model_version,
+                  pretrained_model_config=pretrained_proto,
+                  description=description,
+                  output_info=resources_pb2.OutputInfo(params_specs=inference_param_proto)),
+          ))
+
+    def _uploading(chunk, part_id, range_start, model_version):
+      return service_pb2.PostModelVersionsUploadRequest(
+          content_part=resources_pb2.UploadContentPart(
+              data=chunk, part_number=part_id, range_start=range_start))
+
+    finished_status = [status_code_pb2.SUCCESS, status_code_pb2.UPLOAD_DONE]
+    uploading_in_progress_status = [
+        status_code_pb2.UPLOAD_IN_PROGRESS, status_code_pb2.MODEL_UPLOADING
+    ]
+
+    def _save_cache(cache: dict):
+      if not no_cache:
+        os.makedirs(cache_dir, exist_ok=True)
+        with open(cache_upload_file, "w") as fp:
+          json.dump(cache, fp, indent=2)
+
+    def stream_request(fp, part_id, end_part_id, chunk_size, version):
+      yield init_model_version_upload(version)
+      for iter_part_id in range(part_id, end_part_id):
+        chunk = fp.read(chunk_size)
+        if not chunk:
+          return
+        yield _uploading(
+            chunk=chunk,
+            part_id=iter_part_id,
+            range_start=chunk_size * (iter_part_id - 1),
+            model_version=version)
+
+    tqdm_loader = tqdm(total=100)
+    if model_version:
+      desc = f"Uploading model `{self.id}` version `{model_version}` ..."
+    else:
+      desc = f"Uploading model `{self.id}` ..."
+    tqdm_loader.set_description(desc)
+
+    cache_uploading_info = {}
+    cache_uploading_info["part_id"] = part_id
+    cache_uploading_info["model_version"] = model_version
+    cache_uploading_info["range_start"] = range_start
+    cache_uploading_info["chunk_size"] = chunk_size
+    cache_uploading_info["last_percent"] = last_percent
+    tqdm_loader.update(last_percent)
+    last_part_id = part_id
+    n_chunks = file_size // chunk_size
+    n_chunk_per_stream = MAX_SIZE_PER_STREAM // chunk_size or 1
+
+    def stream_and_logging(request, tqdm_loader, cache_uploading_info, expected_steps: int = None):
+      for st_step, st_response in enumerate(self.auth_helper.get_stub().PostModelVersionsUpload(
+          request, metadata=self.auth_helper.metadata)):
+        if st_response.status.code in uploading_in_progress_status:
+          if cache_uploading_info["model_version"]:
+            assert st_response.model_version_id == cache_uploading_info[
+                "model_version"], RuntimeError
+          else:
+            cache_uploading_info["model_version"] = st_response.model_version_id
+          if st_step > 0:
+            cache_uploading_info["part_id"] += 1
+            cache_uploading_info["range_start"] += chunk_size
+            _save_cache(cache_uploading_info)
+
+            if st_response.status.percent_completed:
+              step_percent = st_response.status.percent_completed - cache_uploading_info["last_percent"]
+              cache_uploading_info["last_percent"] += step_percent
+              tqdm_loader.set_description(
+                  f"{st_response.status.description}, {st_response.status.details}, version id  {cache_uploading_info.get('model_version')}"
+              )
+              tqdm_loader.update(step_percent)
+        elif st_response.status.code not in finished_status + uploading_in_progress_status:
+          # TODO: Find better way to handle error
+          if expected_steps and st_step < expected_steps:
+            raise Exception(f"Failed to upload model, error: {st_response.status}")
+
+    with open(file_path, 'rb') as fp:
+      # seeking
+      for _ in range(1, last_part_id):
+        fp.read(chunk_size)
+      # Stream even part
+      end_part_id = n_chunks or 1
+      for iter_part_id in range(int(last_part_id), int(n_chunks), int(n_chunk_per_stream)):
+        end_part_id = iter_part_id + n_chunk_per_stream
+        if end_part_id >= n_chunks:
+          end_part_id = n_chunks
+        expected_steps = end_part_id - iter_part_id + 1  # init step
+        st_reqs = stream_request(
+            fp,
+            iter_part_id,
+            end_part_id=end_part_id,
+            chunk_size=chunk_size,
+            version=cache_uploading_info["model_version"])
+        stream_and_logging(st_reqs, tqdm_loader, cache_uploading_info, expected_steps)
+      # Stream last part
+      accum_size = (end_part_id - 1) * chunk_size
+      remained_size = file_size - accum_size if accum_size >= 0 else file_size
+      st_reqs = stream_request(
+          fp,
+          end_part_id,
+          end_part_id=end_part_id + 1,
+          chunk_size=remained_size,
+          version=cache_uploading_info["model_version"])
+      stream_and_logging(st_reqs, tqdm_loader, cache_uploading_info, 2)
+
+    # clean up cache
+    if not no_cache:
+      try:
+        os.remove(cache_upload_file)
+      except Exception:
+        _save_cache({})
+
+    if cache_uploading_info["last_percent"] <= 100:
+      tqdm_loader.update(100 - cache_uploading_info["last_percent"])
+      tqdm_loader.set_description("Upload done")
+
+    tqdm_loader.set_description(
+        f"Success uploading model {self.id}, new version {cache_uploading_info.get('model_version')}"
+    )
+
+    return Model.from_auth_helper(
+        auth=self.auth_helper,
+        model_id=self.id,
+        model_version=dict(id=cache_uploading_info.get('model_version')))
+
+  def create_version_by_url(self,
+                            url: str,
+                            input_field_maps: dict,
+                            output_field_maps: dict,
+                            inference_parameter_configs: List[dict] = None,
+                            description: str = "") -> 'Model':
+    """Upload a new version of an existing model in the Clarifai platform using direct download url.
+
+    Args:
+      url (str]): url of zip of model
+      input_field_maps (dict): a dict where the key is clarifai input field and the value is triton model input,
+          {clarifai_input_field: triton_input_filed}.
+      output_field_maps (dict): a dict where the keys are clarifai output fields and the values are triton model outputs,
+          {clarifai_output_field1: triton_output_filed1, clarifai_output_field2: triton_output_filed2,...}.
+      inference_parameter_configs (List[dict]): list of dicts - keys are path, field_type, default_value, description. Default is None
+      description (str): Model description.
+
+    Return:
+      Model: instance of Model with new created version
+    """
+
+    pretrained_proto = Model._make_pretrained_config_proto(
+        input_field_maps=input_field_maps, output_field_maps=output_field_maps, url=url)
+    inference_param_proto = Model._make_inference_params_proto(
+        inference_parameter_configs) if inference_parameter_configs else None
+    request = service_pb2.PostModelVersionsRequest(
+        user_app_id=self.user_app_id,
+        model_id=self.id,
+        model_versions=[
+            resources_pb2.ModelVersion(
+                pretrained_model_config=pretrained_proto,
+                description=description,
+                output_info=resources_pb2.OutputInfo(params_specs=inference_param_proto))
+        ])
+    response = self._grpc_request(self.STUB.PostModelVersions, request)
+
+    if response.status.code != status_code_pb2.SUCCESS:
+      raise Exception(f"Failed to upload model, error: {response.status}")
+    self.logger.info(
+        f"Success uploading model {self.id}, new version {response.model.model_version.id}")
+
+    return Model.from_auth_helper(
+        auth=self.auth_helper,
+        model_id=self.id,
+        model_version=dict(id=response.model.model_version.id))