clarifai 9.10.2__py3-none-any.whl → 9.10.3__py3-none-any.whl

clarifai_utils/models/api.py

@@ -1,283 +0,0 @@
-# Copyright 2023 Clarifai, Inc.
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Interface to Clarifai Models API."""
-
-from typing import Dict, List, Type
-
-from clarifai_grpc.grpc.api import resources_pb2, service_pb2
-from google.protobuf.json_format import MessageToDict
-from google.protobuf.struct_pb2 import Struct, Value
-
-from clarifai.auth.helper import ClarifaiAuthHelper
-from clarifai.client import create_stub
-
-
-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)
-
-
-class Models:
-  """
-  Interface to Clarifai models api
-  """
-
-  def __init__(self, auth: Type[ClarifaiAuthHelper]) -> None:
-    self.auth = auth
-    self.stub = create_stub(self.auth)
-
-  def list_model_types(self) -> Dict:
-    """
-    List all API Model Types that support input and output.
-
-    Returns:
-      - A dict of;
-          model_type, [{expected_input_name: value}, {expected_output_name: value}, model_descripton]
-        key, value pairs respectively.i.e.
-          {model_type: [{inp_field_name: value}, {output_field_name: value,...}, model_description]}
-
-      - model_type: supported input shapes and data types dict. Structure;
-          {model_type: [(supported_input_N_dims, dtypes_N),...]}
-
-      - model_type: supported output shapes and data types dict. Structure;
-          {model_type: [(supported_output_N_dims, dtypes_N),...]}
-    """
-    ## List model types from API
-    model_types_response = self.stub.ListModelTypes(
-        service_pb2.ListModelTypesRequest(),  #(user_app_id=auth.user_app_id),
-        metadata=self.auth.metadata)
-    # model types dict structure:
-    # {model_type: [{inp_field_name: value,}, {output_field_name: value,...}, desc]}
-    model_types = {}
-    in_dims_dtype = {}  # {model_type: [(supported_input_N_dims, dtypes_N),...]}
-    out_dims_dtype = {}  # {model_type: [(supported_output_N_dims, dtypes_N),...]}
-    types_dict = MessageToDict(
-        model_types_response, preserving_proto_field_name=True)['model_types']
-    for i in range(len(types_dict)):
-      model_id = types_dict[i]['id']
-      model_desc = types_dict[i]['description']
-      if 'expected_output_layers' in types_dict[i].keys():
-        # expected_input_layers exist for all expected_output_layers
-        # hence one conditional check
-        model_types[model_id] = []
-        in_dims_dtype[model_id] = []
-        out_dims_dtype[model_id] = []
-        expected_input = types_dict[i]['expected_input_layers']
-        expected_output = types_dict[i]['expected_output_layers']
-        for inp in expected_input:
-          if 'data_field_name' in inp.keys():
-            model_types[model_id].append({inp['data_field_name']: None})
-          if 'shapes' in inp.keys():
-            for dim in inp['shapes']:
-              if 'dims' in dim.keys():
-                if 'max_dims' in dim.keys():
-                  in_dims_dtype[model_id].append((dim['dims'], dim['max_dims'], dim['data_type']))
-                else:
-                  in_dims_dtype[model_id].append((dim['dims'], dim['data_type']))
-          continue
-        temp_out = {}
-        for each in expected_output:
-          if 'data_field_name' in each.keys():
-            temp_out[each['data_field_name']] = None
-          if 'shapes' in each.keys():
-            for dim in each['shapes']:
-
-              if 'dims' in dim.keys():
-                out_dims_dtype[model_id].append((dim['dims'], dim['data_type']))
-          else:
-            continue
-        model_types[model_id].append(temp_out)
-        model_types[model_id].append(model_desc)
-
-    return {
-        "Model Types": model_types,
-        "Input Metadata": in_dims_dtype,
-        "Output Metadata": out_dims_dtype
-    }
-
-  def init_model(
-      self,
-      model_id: str,
-      model_type: str,
-      description: str = "",
-  ):
-    """Init a new model on Clarifai platform.
-
-    Args:
-        model_id (str): Clarifai model id
-        model_type (str): Clarifai model type
-        description (str, optional): a description of the model. Defaults to "".
-
-    Returns:
-        dict: Clarifai api response
-    """
-    user_data_object = self.auth.get_user_app_id_proto()
-    post_models_response = self.stub.PostModels(
-        service_pb2.PostModelsRequest(
-            user_app_id=user_data_object,
-            models=[resources_pb2.Model(id=model_id, notes=description,
-                                        model_type_id=model_type)]),
-        metadata=self.auth.metadata)
-
-    return MessageToDict(post_models_response, preserving_proto_field_name=True)
-
-  def post_model_version(self,
-                         model_id: str,
-                         model_zip_url: str,
-                         input: dict,
-                         outputs: dict,
-                         param_specs: List[dict] = None):
-    """Post a new version of an existing model in the Clarifai platform.
-
-    Args:
-        model_id (str): Clarifai model id
-        model_zip_url (str]): url of zip of model
-        model_zip_url (str): url of zip of model
-        input (dict): a dict where the key is clarifai input field and the value is triton model input,
-            {clarifai_input_field: triton_input_filed}.
-        outputs (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,...}.
-        param_specs (List[dict]): list of dicts - keys are path, field_type, default_value, description. Default is None
-    Returns:
-        dict: clarifai api response
-    """
-    user_data_object = self.auth.get_user_app_id_proto()
-
-    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)
-    output_fields_map = _parse_fields_map(outputs)
-    #resources_pb2.ModelTypeField(path="abc", default_value=1, description="test")
-    if param_specs:
-      iterative_proto_params = []
-      for param in param_specs:
-        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)
-      param_specs = iterative_proto_params
-
-    post_model_versions = self.stub.PostModelVersions(
-        service_pb2.PostModelVersionsRequest(
-            user_app_id=user_data_object,
-            model_id=model_id,
-            model_versions=[
-                resources_pb2.ModelVersion(
-                    pretrained_model_config=resources_pb2.PretrainedModelConfig(
-                        model_zip_url=model_zip_url,
-                        input_fields_map=input_fields_map,
-                        output_fields_map=output_fields_map),
-                    output_info=resources_pb2.OutputInfo(params_specs=param_specs))
-            ]),
-        metadata=self.auth.metadata)
-
-    return MessageToDict(post_model_versions, preserving_proto_field_name=True)
-
-  def upload_model(self,
-                   model_id: str,
-                   model_zip_url: str,
-                   input: dict,
-                   outputs: dict,
-                   model_type: str,
-                   description: str = "",
-                   param_specs: List[dict] = None):
-    """Doing 2 requests for initializing and creating version for a new trained model to the Clarifai platform.
-
-    Args:
-        model_id (str): Clarifai model id
-        model_zip_url (str): url of zip of model
-        input (dict): a dict where the key is clarifai input field and the value is triton model input,
-            {clarifai_input_field: triton_input_filed}
-        outputs (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,...}
-        model_type (str): Clarifai model type.
-        description (str, optional): a description of the model. Defaults to "".
-        param_specs (List[dict]): list of dicts - keys are path, field_type, default_value, description. Default is None
-
-    Returns:
-        dict: Clarifai api response
-    """
-    init_resp = self.init_model(model_id, model_type, description)
-    if init_resp["status"]["code"] != "SUCCESS":
-      return init_resp
-    version_resp = self.post_model_version(model_id, model_zip_url, input, outputs, param_specs)
-
-    return version_resp
-
-  def delete_model(self, model_id: str):
-    """Delete model api by model id
-
-    Args:
-        model_id (str): Clarifai model id
-
-    Returns:
-        dict: clarifai api response
-    """
-    user_data_object = self.auth.get_user_app_id_proto()
-    delete_model_response = self.stub.DeleteModel(
-        service_pb2.DeleteModelRequest(
-            user_app_id=user_data_object,
-            model_id=model_id,
-        ),
-        metadata=self.auth.metadata)
-
-    return MessageToDict(delete_model_response, preserving_proto_field_name=True)
-
-  def delete_model_version(self, model_id: str, version_id: str):
-    """Delete specific version of model
-
-    Args:
-        model_id (str): Clarifai model id
-        version_id (str): version id of model that will be removed
-
-    Returns:
-        dict: Clarifai API response
-    """
-    user_data_object = self.auth.get_user_app_id_proto()
-    delete_model_response = self.stub.DeleteModelVersion(
-        service_pb2.DeleteModelVersionRequest(
-            user_app_id=user_data_object, model_id=model_id, version_id=version_id),
-        metadata=self.auth.metadata)
-
-    return MessageToDict(delete_model_response, preserving_proto_field_name=True)
-
-  def get_model(self, model_id: str):
-    """Get model by id
-
-    Args:
-        model_id (str): Clarifai model id
-
-    Returns:
-        dict: Clarifai API response
-    """
-    user_data_object = self.auth.get_user_app_id_proto()
-    response = self.stub.GetModel(
-        service_pb2.GetModelRequest(
-            user_app_id=user_data_object,
-            model_id=model_id,
-        ),
-        metadata=self.auth.metadata)
-
-    return MessageToDict(response, preserving_proto_field_name=True)

clarifai_utils/models/model_serving/README.md

@@ -1,155 +0,0 @@
-## Clarifai Model Serving: Deploy Your Machine Learning Models to Clarifai.
-
-Build and easily deploy machine learning models to Clarifai for inference using the [Nvidia Triton Inference Server](https://github.com/triton-inference-server/server).
-
-## QuickStart Guide: Build a deployment ready model.
-
-A step by step guide to building your own triton inference model and deploying it into a Clarifai app.
-
-1. Generate a triton model repository via commandline.
-```console
-clarifai-model-upload-init --model_name <Your model name> \
-		--model_type <select model type from available ones> \
-		--repo_dir <directory in which to create your model repository>
-```
-2.  1. Edit the `requirements.txt` file with dependencies needed to run inference on your model and the `labels.txt` (if available in dir) with the labels your model is to predict.
-    2.  Add your model loading and inference code inside `inference.py` script of the generated model repository under the `setup()` and `predict()` functions respectively. Refer to  The [Inference Script section]() for a description of this file.
-    3. Inference parameters (optional): you can define some inference parameters that can be adjusted on model view of Clarifai platform when making prediction. Follow [this doc](./docs/inference_parameters.md) to build the json file.
-3. Testing (Recommend) your implementation locally by running `<your_triton_folder>/1/test.py` with basic predefined tests.
-To avoid missing dependencies when deploying, recommend to use conda to create clean environment. Then install everything in `requirements.txt`. Follow instruction inside [test.py](./models/test.py) for implementing custom tests.
-  * Create conda env and install requirements:
-```bash
-# create env (note: only python version 3.8 is supported currently)
-conda create -n <your_env> python=3.8
-# activate it
-conda activate <your_env>
-# install dependencies
-pip install -r <your_triton_folder>/requirements.txt
-```
-* Then run the test by using pytest:
-
-```bash
-  # Run the test
-  pytest ./your_triton_folder/1/test.py
-  # to see std output
-  pytest --log-cli-level=INFO  -s ./your_triton_folder/1/test.py
-```
-4. Generate a zip of your triton model for deployment via commandline.
-```console
-clarifai-triton-zip --triton_model_repository <path to triton model repository to be compressed> \
-    --zipfile_name <name of the triton model zip> (Recommended to use 	  <model_name>_<model-type> convention for naming)
-```
-5. Upload the generated zip to a public file storage service to get a URL to the zip. This URL must be publicly accessible and downloadable as it's necessary for the last step: uploading the model to a Clarifai app.
-6. Set your Clarifai auth credentials as environment variables.
-```console
-export CLARIFAI_USER_ID=<your clarifai user_id>
-export CLARIFAI_APP_ID=<your clarifai app_id>
-export CLARIFAI_PAT=<your clarifai PAT>
-```
-7. Upload your model to Clarifai. Please ensure that your configuration field maps adhere to [this](https://github.com/Clarifai/clarifai-python-utils/blob/main/clarifai/models/model_serving/model_config/deploy.py)
-```console
-clarifai-upload-model --url <URL to your model zip. Your zip file name is expected to have "zipfile_name" format (in clarifai-triton-zip), if not you need to specify your model_id and model_type> \
-    --model_id <Your model ID on the platform> \
-    --model_type <Clarifai model types> \
-    --desc <A description of your model> \
-    --update_version <Optional. Add new version of existing model>  \
-    --infer_param <Optional. Path to json file contains inference parameters>
-```
-
-* Finally, navigate to your Clarifai app models and check that the deployed model appears. Click it on the model name to go the model versions table to track the status of the model deployment.
-
-## Triton Model Repository
-```diff
-    <model_name>/
-    ├── config.pbtx
-    ├── requirements.txt
-    ├── labels.txt (If applicable for given model-type)
--   ├── triton_conda.yaml
-    └── 1/
-        ├── __init__.py
-        ├── inference.py
-        ├── test.py
-        └── model.py
-```
-
-A generated triton model repository looks as illustrated in the directory tree above. Any additional files such as model checkpoints and folders needed at inference time must all be placed under the `1/` directory.
-
-- File Descriptions
-
-| Filename | Description & Use |
-| --- | --- |
-| `config.pbtxt` | Contains the triton model configuration used by the triton inference server to guide inference requests processing. |
-| `requirements.txt` | Contains dependencies needed by a user model to successfully make predictions.|
-| `labels.txt` | Contains labels listed one per line, a model is trained to predict. The order of labels should match the model predicted class indexes. |
-| `triton_conda.yaml` | Contains dependencies available in pre-configured execution environment. |
-| `1/inference.py` | The inference script where users write their inference code. |
-| `1/model.py` | The triton python backend model file run to serve inference requests. |
-| `1/test.py` | Contains some predefined tests in order to test inference implementation and dependencies locally. |
-
-## Inference Script
-
-An `inference.py` script with template code is generated during the triton model repository generation.
-**This is the script where users write their inference code**.
-This script is composed of a single class that contains a default init method and the `get_predictions()` method whose names mustn't be changed.
-
-```python
-"""User model inference script."""
-
-import os
-from pathlib import Path
-from typing import Callable
-
-class InferenceModel:
-  """User model inference class."""
-
-  def __init__(self) -> None:
-    """
-    Load inference time artifacts that are called frequently .e.g. models, tokenizers, etc.
-    in this method so they are loaded only once for faster inference.
-    """
-    self.base_path: Path = os.path.dirname(__file__)
-    ## sample model loading code:
-    #self.checkpoint_path: Path = os.path.join(self.base_path, "your checkpoint filename/path")
-    #self.model: Callable = <load_your_model_here from checkpoint or folder>
-
-  #Add relevant model type decorator to the method below (see docs/model_types for ref.)
-  def get_predictions(self, input_data, **kwargs):
-    """
-    Main model inference method.
-
-    Args:
-    -----
-      input_data: A single input data item to predict on.
-        Input data can be an image or text, etc depending on the model type.
-
-    Returns:
-    --------
-      One of the clarifai.models.model_serving.models.output types. Refer to the README/docs
-    """
-    # Delete/Comment out line below and add your inference code
-    raise NotImplementedError()
-```
-
-- `__init__()` used for one-time loading of inference time artifacts such as models, tokenizers, etc that are frequently called during inference to improve inference speed.
-
-- `get_predictions()` takes an input data item whose type depends on the task the model solves, & returns predictions for an input data item.
-
-`get_predictions()` should return any of the output types defined under [output](docs/output.md) and the predict function MUST be decorated with a task corresponding [model type decorator](docs/model_types.md). The model type decorators are responsible for passing input request batches for prediction and formatting the resultant predictions into triton inference responses.
-
-Additional methods can be added to this script's `Infer` class by the user as deemed necessary for their model inference provided they are invoked inside `get_predictions()` if used at inference time.
-
-## Next steps
-
-- [Model types docs](docs/model_types.md)
-- [Model Output types docs](docs/output.md)
-- [Dependencies](docs/dependencies.md)
-- [Examples](examples/)
-- [Custom Configs](docs/custom_config.md/)
-
-## Prerequisites
-
-* For deployment to Clarifai, you need a [Clarifai account](https://clarifai.com/signup).
-
-## Testing
-
-* Please see https://github.com/Clarifai/clarifai-python/blob/master/clarifai/models/model_serving/models/test.py

clarifai_utils/models/model_serving/__init__.py

@@ -1,12 +0,0 @@
-# Copyright 2023 Clarifai, Inc.
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.

clarifai_utils/models/model_serving/cli/__init__.py

@@ -1,12 +0,0 @@
-# Copyright 2023 Clarifai, Inc.
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.

clarifai_utils/models/model_serving/cli/deploy_cli.py

@@ -1,123 +0,0 @@
-# Copyright 2023 Clarifai, Inc.
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Commandline interface for model upload utils."""
-import argparse
-
-from clarifai.auth.helper import ClarifaiAuthHelper
-from clarifai.models.api import Models
-from clarifai.models.model_serving.model_config import MODEL_TYPES, get_model_config
-from clarifai.models.model_serving.model_config.inference_parameter import InferParamManager
-
-
-def deploy(model_url,
-           model_id: str = None,
-           model_type: str = None,
-           desc: str = "",
-           update_version: bool = False,
-           inference_params_file: str = ""):
-  # init Auth from env vars
-  auth = ClarifaiAuthHelper.from_env()
-  # init api
-  model_api = Models(auth)
-
-  # parsing model name/type.
-  # if filename having this format: <model_id>_<model-type>
-  # e.i yolov5s_coco_visual-dectector
-  # else user has to input model_type and model_id
-  zip_filename = model_url.split('/')[-1]
-  zip_filename = zip_filename.split('.')[0]
-
-  def _parse_name(name):
-    *id_, type_ = name.split('_')
-    return "_".join(id_), type_
-
-  # parse model_id
-  if not model_id and "_" in zip_filename:
-    model_id = _parse_name(zip_filename)[0]
-  assert model_id, "Can not parse model_id from url, please input it directly"
-  # parse model_type
-  if not model_type and "_" in zip_filename:
-    model_type = _parse_name(zip_filename)[-1]
-  assert model_type, "Can not parse model_type from url, please input it directly"
-  # 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).field_maps
-  # inference parameters
-  inference_parameters = InferParamManager(json_path=inference_params_file).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"]}')
-
-
-def main():
-  parser = argparse.ArgumentParser(description=__doc__)
-  # args
-  parser.add_argument("--url", type=str, required=True, help="Direct download url of zip file")
-  parser.add_argument("--model_id", type=str, required=False, default="", help="Custom model id.")
-  parser.add_argument(
-      "--model_type",
-      type=str,
-      required=False,
-      choices=MODEL_TYPES,
-      default="",
-      help="Clarifai model type")
-  parser.add_argument(
-      "--desc", type=str, required=False, default="", help="Short desccription of model")
-  parser.add_argument(
-      "--update_version",
-      action="store_true",
-      required=False,
-      help="Update exist model with new version")
-
-  parser.add_argument(
-      "--infer_param",
-      required=False,
-      default="",
-      help="Path to json file contains inference parameters")
-
-  args = parser.parse_args()
-  deploy(
-      model_url=args.url,
-      model_id=args.model_id,
-      desc=args.desc,
-      model_type=args.model_type,
-      update_version=args.update_version,
-      inference_params_file=args.infer_param)
-
-
-if __name__ == "__main__":
-  main()

clarifai_utils/models/model_serving/cli/model_zip.py

@@ -1,61 +0,0 @@
-# Copyright 2023 Clarifai, Inc.
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""Triton model zip commandline interface."""
-
-import argparse
-import zipfile
-from pathlib import Path
-from typing import Union
-
-
-def zip_dir(triton_repository_dir: Union[Path, str], zip_filename: Union[Path, str]):
-  """
-  Generate triton model repository zip file for upload.
-  Args:
-  -----
-  triton_repository_dir: Directory of triton model respository to be zipped
-  zip_filename: Triton model repository zip filename
-
-  Returns:
-  --------
-  None
-  """
-  # Convert to Path object
-  dir = Path(triton_repository_dir)
-
-  with zipfile.ZipFile(zip_filename, "w", zipfile.ZIP_DEFLATED) as zip_file:
-    for entry in dir.rglob("*"):
-      zip_file.write(entry, entry.relative_to(dir))
-
-
-def main():
-  """Triton model zip cli."""
-  parser = argparse.ArgumentParser(__doc__)
-  parser.add_argument(
-      "--triton_model_repository",
-      type=str,
-      required=True,
-      help="Path to the triton model repository to zip.")
-  parser.add_argument(
-      "--zipfile_name",
-      type=str,
-      required=True,
-      help="Name of the zipfile to be created. \
-      <model_name>_<model_type> is the recommended naming convention.e.g. yolov5_visual-detector.zip"
-  )
-  args = parser.parse_args()
-  zip_dir(args.triton_model_repository, args.zipfile_name)
-
-
-if __name__ == "__main__":
-  main()