clarifai 10.0.1__py3-none-any.whl → 10.1.1__py3-none-any.whl

clarifai/models/model_serving/cli/create.py

@@ -0,0 +1,171 @@
+import os
+import shutil
+from argparse import Namespace, _SubParsersAction
+from typing import List
+
+from InquirerPy import prompt
+
+from ..model_config import MODEL_TYPES
+from ..repo_build import RepositoryBuilder
+from ._utils import list_model_upload_examples
+from .base import BaseClarifaiCli
+
+
+class CreateCli(BaseClarifaiCli):
+
+  @staticmethod
+  def register(parser: _SubParsersAction):
+    creator_parser = parser.add_parser("create", help="Create component of Clarifai platform")
+    sub_creator_parser = creator_parser.add_subparsers()
+
+    SubCreateModelCli.register(sub_creator_parser)
+
+    creator_parser.set_defaults(func=CreateCli)
+
+
+class SubCreateModelCli(BaseClarifaiCli):
+
+  @staticmethod
+  def register(parser: _SubParsersAction):
+    model_parser = parser.add_parser("model")
+    model_parser.add_argument(
+        "--working-dir",
+        type=str,
+        required=True,
+        help="Path to your working dir. Create new dir if it does not exist")
+    model_parser.add_argument(
+        "--from-example",
+        required=False,
+        action="store_true",
+        help="Create repository from example")
+    model_parser.add_argument(
+        "--example-id",
+        required=False,
+        type=str,
+        help="Example id, run `clarifai example list` to list of examples")
+
+    model_parser.add_argument(
+        "--type",
+        type=str,
+        choices=MODEL_TYPES,
+        required=False,
+        help="Clarifai supported model types.")
+    model_parser.add_argument(
+        "--image-shape",
+        nargs='+',
+        type=int,
+        required=False,
+        help="H W dims for models with an image input type. H and W each have a max value of 1024",
+        default=[-1, -1])
+    model_parser.add_argument(
+        "--max-bs", type=int, default=1, required=False, help="Max batch size")
+
+    model_parser.add_argument(
+        "--overwrite", action="store_true", help="Overwrite working-dir if exists")
+
+    model_parser.set_defaults(func=SubCreateModelCli)
+
+  def __init__(self, args: Namespace) -> None:
+    self.working_dir: str = args.working_dir
+    self.from_example = args.from_example
+    self.example_id = args.example_id
+    self.overwrite = args.overwrite
+
+    if os.path.exists(self.working_dir):
+      if self.overwrite:
+        print(f"Overwrite {self.working_dir}")
+      else:
+        raise FileExistsError(
+            f"{self.working_dir} exists. If you want to overwrite it, please set `--overwrite` flag"
+        )
+
+    # prevent wrong args when creating from example
+    if not self.from_example:
+      self.image_shape: List[int] = args.image_shape
+
+      self.type: str = args.type
+      self.max_bs: int = args.max_bs
+
+    else:
+      if not self.example_id:
+        questions = [
+            {
+                "type": "list",
+                "message": "Select an example:",
+                "choices": list_model_upload_examples(),
+            },
+        ]
+        result = prompt(questions)
+        self.example_id = result[0]
+
+      else:
+        available_examples = list(list_model_upload_examples().keys())
+        assert self.example_id in available_examples, f"Available examples are: {available_examples}, got {self.example_id}."
+
+  def run(self):
+    if self.from_example:
+      os.makedirs(self.working_dir, exist_ok=True)
+      model_repo, readme = list_model_upload_examples()[self.example_id]
+      shutil.copytree(model_repo, self.working_dir, dirs_exist_ok=True)
+      if readme:
+        shutil.copy(readme, os.path.join(self.working_dir, "readme.md"))
+
+    else:
+      RepositoryBuilder.init_repository(
+          self.type,
+          self.working_dir,
+          backend="triton",
+          max_batch_size=self.max_bs,
+          image_shape=self.image_shape)
+
+    from itertools import islice
+    from pathlib import Path
+
+    def tree(dir_path: Path,
+             level: int = -1,
+             limit_to_directories: bool = False,
+             length_limit: int = 1000):
+      # prefix components:
+      space = '    '
+      branch = '│   '
+      # pointers:
+      tee = '├── '
+      last = '└── '
+      """Given a directory Path object print a visual tree structure"""
+      dir_path = Path(dir_path)  # accept string coerceable to Path
+      files = 0
+      directories = 0
+
+      def inner(dir_path: Path, prefix: str = '', level=-1):
+        nonlocal files, directories
+        if not level:
+          return  # 0, stop iterating
+        if limit_to_directories:
+          contents = [d for d in dir_path.iterdir() if d.is_dir()]
+        else:
+          contents = list(dir_path.iterdir())
+        pointers = [tee] * (len(contents) - 1) + [last]
+        for pointer, path in zip(pointers, contents):
+          if path.is_dir():
+            yield prefix + pointer + path.name
+            directories += 1
+            extension = branch if pointer == tee else space
+            yield from inner(path, prefix=prefix + extension, level=level - 1)
+          elif not limit_to_directories:
+            yield prefix + pointer + path.name
+            files += 1
+
+      print(dir_path.name)
+      iterator = inner(dir_path, level=level)
+      for line in islice(iterator, length_limit):
+        print(line)
+      if next(iterator, None):
+        print(f'... length_limit, {length_limit}, reached, counted:')
+      print(f'\n{directories} directories' + (f', {files} files' if files else ''))
+
+    print("-" * 75)
+    print(f"* Created repository at: {self.working_dir}")
+    tree(self.working_dir)
+    print()
+    print("* Please make sure your code is tested using `test.py` before uploading")
+    print("-" * 75)

clarifai/models/model_serving/cli/example_cli.py

@@ -0,0 +1,34 @@
+from argparse import Namespace, _SubParsersAction
+
+from ._utils import list_model_upload_examples
+from .base import BaseClarifaiCli
+
+
+class ExampleCli(BaseClarifaiCli):
+
+  @staticmethod
+  def register(parser: _SubParsersAction):
+    creator_parser = parser.add_parser("example", help="Download/List examples of model upload")
+    sub_creator_parser = creator_parser.add_subparsers()
+
+    SubListExampleCli.register(sub_creator_parser)
+
+    creator_parser.set_defaults(func=ExampleCli)
+
+
+class SubListExampleCli(BaseClarifaiCli):
+
+  @staticmethod
+  def register(parser: _SubParsersAction):
+    _parser = parser.add_parser("list")
+    _parser.add_argument("--force-download", action="store_true", help="Force download examples")
+    _parser.set_defaults(func=SubListExampleCli)
+
+  def __init__(self, args: Namespace) -> None:
+    self.force_download = args.force_download
+
+  def run(self):
+    _list = list_model_upload_examples(self.force_download)
+    print(f"Found {len(_list)} examples")
+    for each in _list:
+      print(f" * {each}")

clarifai/models/model_serving/cli/login.py

@@ -0,0 +1,26 @@
+import argparse
+
+from ..constants import CLARIFAI_PAT_PATH
+from ..utils import _persist_pat
+from .base import BaseClarifaiCli
+
+
+class LoginCli(BaseClarifaiCli):
+
+  @staticmethod
+  def register(parser: argparse._SubParsersAction):
+    upload_parser = parser.add_parser("login", help="Login to Clarifai and save PAT locally")
+    upload_parser.set_defaults(func=LoginCli)
+
+  def __init__(self, args: argparse.Namespace) -> None:
+    pass
+
+  def _parse_config(self):
+    # do something with self.config_path
+    raise NotImplementedError()
+
+  def run(self):
+    msg = "Get your PAT from https://clarifai.com/settings/security and pass it here: "
+    _pat = input(msg)
+    _persist_pat(_pat)
+    print(f"Your PAT is saved at {CLARIFAI_PAT_PATH}")

clarifai/models/model_serving/cli/upload.py

@@ -0,0 +1,182 @@
+# 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
+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.inference_parameter import InferParamManager
+
+from ..utils import login
+from .base import BaseClarifaiCli
+
+
+class UploadCli(BaseClarifaiCli):
+
+  @staticmethod
+  def register(parser: argparse._SubParsersAction):
+    creator_parser = parser.add_parser("upload", help="Upload component to Clarifai platform")
+    sub_creator_parser = creator_parser.add_subparsers()
+
+    UploadModelSubCli.register(sub_creator_parser)
+
+    creator_parser.set_defaults(func=UploadCli)
+
+
+class UploadModelSubCli(BaseClarifaiCli):
+
+  @staticmethod
+  def register(parser: argparse._SubParsersAction):
+    upload_parser = parser.add_parser("model", help="Upload Clarifai model")
+    upload_parser.add_argument(
+        "path",
+        type=str,
+        nargs='?',
+        help=
+        "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")
+    upload_parser.add_argument("--id", type=str, required=False, help="Model ID")
+    upload_parser.add_argument(
+        "--user-app",
+        type=str,
+        required=False,
+        help="User ID and App ID separated by '/', e.g., <user_id>/<app_id>")
+    upload_parser.add_argument(
+        "--no-test",
+        action="store_true",
+        help="Trigger this flag to skip testing before uploading")
+
+    upload_parser.add_argument(
+        "--update-version",
+        action="store_true",
+        required=False,
+        help="Update exist model with new version")
+
+    upload_parser.set_defaults(func=UploadModelSubCli)
+
+  def __init__(self, args: argparse.Namespace) -> None:
+    self.no_test = args.no_test
+
+    working_dir_or_config = args.path
+    # if input a config file, then not running test
+    if working_dir_or_config.endswith(".yaml"):
+      config_yaml_path = working_dir_or_config
+      self.test_path = None
+      self.no_test = True
+    # if it is a directory - working dir then it must contain config and test
+    else:
+      config_yaml_path = os.path.join(working_dir_or_config, "clarifai_config.yaml")
+      self.test_path = os.path.join(working_dir_or_config, "test.py")
+
+    assert os.path.exists(config_yaml_path), FileNotFoundError(
+        f"`{config_yaml_path}` does not exist")
+    self.config = load_user_config(cfg_path=config_yaml_path)
+
+    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
+    self.id = args.id or clarifai_cfg.clarifai_model_id
+    self.type = clarifai_cfg.type
+    self.desc = clarifai_cfg.description
+    self.infer_param = clarifai_cfg.inference_parameters
+    user_app = user_app or clarifai_cfg.clarifai_user_app_id
+
+    if user_app:
+      user_app = user_app.split('/')
+      assert len(
+          user_app
+      ) == 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):
+
+    # Run test before uploading
+    if not self.no_test:
+      assert os.path.exists(self.test_path), FileNotFoundError(f"Not found {self.test_path}")
+      result = subprocess.run(f"pytest -s --log-level=INFO {self.test_path}")
+      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/models/model_serving/constants.py

@@ -1 +1,21 @@
+import os
+
 MAX_HW_DIM = 1024
+IMAGE_TENSOR_NAME = "image"
+TEXT_TENSOR_NAME = "text"
+
+BUILT_MODEL_EXT = ".clarifai"
+
+default_home = os.path.join(os.path.expanduser("~"), ".cache")
+CLARIFAI_HOME = os.path.expanduser(
+    os.getenv(
+        "CLARIFAI_HOME",
+        os.path.join(os.getenv("XDG_CACHE_HOME", default_home), "clarifai"),
+    ))
+os.makedirs(CLARIFAI_HOME, exist_ok=True)
+CLARIFAI_PAT_PATH = os.path.join(CLARIFAI_HOME, "pat")
+
+CLARIFAI_EXAMPLES_REPO = "https://github.com/Clarifai/examples.git"
+repo_name = CLARIFAI_EXAMPLES_REPO.split("/")[-1].replace(".git", "")
+CLARIFAI_EXAMPLES_REPO_PATH = os.path.join(CLARIFAI_HOME, repo_name)
+MODEL_UPLOAD_EXAMPLE_FOLDER = "model_upload"

clarifai/models/model_serving/docs/cli.md

@@ -0,0 +1,150 @@
+# CLI helpers
+
+Supported cli:
+
+```bash
+$ clarifai -h
+upload              Upload component to Clarifai platform
+create              Create component of Clarifai platform
+login               Login to Clarifai and save PAT locally
+example             Download/List examples of model upload
+build               Build clarifai model for uploading
+```
+
+1. Login
+
+```bash
+$ clarifai login
+Get your PAT from https://clarifai.com/settings/security and pass it here: <your pat>
+```
+
+2. Create model repository
+
+Initialize template for specify model type in provided directory
+
+* `From scratch`:
+
+```bash
+$ clarifai create model --type <model-type> --working-dir <your_working_dir>
+```
+
+* `From example`:
+
+```bash
+$ clarifai create model --from-example --working-dir <your_working_dir>
+? Select an example:
+❯ multimodal_embedder/clip
+  text_classifier/xlm-roberta
+  text_embedder/instructor-xl
+  ...
+```
+
+Then will see below output
+
+```bash
+---------------------------------------------------------------------------
+* Created repository at: ./<your_working_dir>
+<your_working_dir>
+├── clarifai_config.yaml
+├── inference.py
+├── requirements.txt
+└── test.py
+
+0 directories, 4 files
+
+* Please make sure your code is tested using `test.py` before uploading
+---------------------------------------------------------------------------
+```
+
+> NOTE: if working-dir exists, need to set --overwrite flag otherwise an error arises
+
+Full arguments
+
+```bash
+$ clarifai create model -h
+--working-dir         Path to your working dir. Create new dir if it does not exist
+--from-example        Create repository from example
+--example-id          Example id, run `clarifai example list` to list of examples
+--type                Clarifai supported model types.
+--image-shape         list of H W dims for models with an image input type. H and W each have a max value of 1024
+--max-bs              Max batch size
+--overwrite           Overwrite working-dir if exists
+```
+
+3. See available examples
+
+```bash
+$ clarifai example list
+Found 11 examples
+ * multimodal_embedder/clip
+ * text_classifier/xlm-roberta
+ * text_embedder/instructor-xl
+  ....
+```
+
+4. Build
+
+This step will run `test.py` in provided working dir as default before building
+
+```
+$ clarifai build model <your_working_dir> --name model-name
+$ tree <your_working_dir> -a
+<your_working_dir>
+├── .cache # (*)
+│   ├── 1
+│   │   ├── clarifai_config.yaml
+│   │   ├── inference.py
+│   │   ├── model.py
+│   │   ├── test.py
+│   │   └── ...
+│   ├── config.pbtxt
+│   └── requirements.txt
+├── clarifai_config.yaml
+├── inference.py
+├── model-name.clarifai # (**)
+├── requirements.txt
+├── test.py
+└── ...
+```
+
+**NOTE:**
+
+(*): Build cache, user can simply ignore it.
+
+(**): zipped of .cache
+
+Full arguments
+
+```bash
+$ clarifai build model -h
+positional arguments:
+  path               Path to working directory, default is current directory
+optional arguments:
+--out-path           Output path of built model
+--name               Name of built file, default is `clarifai_model_id` in config if set or`model`
+--no-test            Trigger this flag to skip testing before uploading
+```
+
+5. Upload
+
+This step will run `test.py` in provided working dir as default before building
+
+```bash
+$ clarifai upload model <your_working_dir> --url <your url>
+```
+
+Full arguments
+
+```bash
+$ clarifai upload model -h
+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
+
+```