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

clarifai/models/model_serving/models/default_test.py

@@ -1,281 +0,0 @@
-import dataclasses
-import inspect
-import logging
-import os
-import unittest
-from typing import Any, Dict, Union
-
-import numpy as np
-
-from ..model_config import ModelTypes
-from ..model_config.config import get_model_config
-from ..model_config.inference_parameter import InferParamManager
-from .output import (ClassifierOutput, EmbeddingOutput, ImageOutput, MasksOutput, TextOutput,
-                     VisualDetectorOutput)
-
-PREDEFINED_TEXTS = ["Photo of a cat", "A cat is playing around"]
-
-PREDEFINED_IMAGES = [
-    np.zeros((100, 100, 3), dtype='uint8'),  #black
-    np.ones((100, 100, 3), dtype='uint8') * 255,  #white
-    np.random.uniform(0, 255, (100, 100, 3)).astype('uint8')  #noise
-]
-
-
-class DefaultTestInferenceModel(unittest.TestCase):
-  """
-  This file contains test cases:
-  * Test triton config of current model vs default config
-  * Test if labels.txt is valid for specific model types
-  * Test inference with simple inputs
-  ...
-  """
-  __test__ = False
-
-  def triton_get_predictions(self, input_data, **kwargs):
-    """Call InferenceModel.get_predictions method
-
-    Args:
-        input_data (Union[np.ndarray, str]):
-          if model receives image or vector then type is `np.ndarray`, otherwise `string`
-
-    Returns:
-       One of types in models.output
-    """
-    _kwargs = self.inference_parameters.validate(**kwargs)
-    return inspect.unwrap(self.triton_python_model.inference_obj.get_predictions)(
-        self.triton_python_model.inference_obj, input_data, **_kwargs)
-
-  def _get_preprocess(self, input):
-    """ preprocess if input is image """
-    if "image" in input.name:
-      h, w, _ = input.dims
-      if h > -1 and w > -1:
-        import cv2
-
-        def _f(x):
-          logging.info(f"Preprocess reshape image => {(w, h, 3)}")
-          return cv2.resize(x, (w, h))
-
-        return _f
-
-    return lambda x: x
-
-  def intitialize(self,
-                  model_type: str,
-                  repo_version_dir: str,
-                  is_instance_kind_gpu: bool = True,
-                  inference_parameters: Union[str, Dict[str, Any]] = ""):
-    import sys
-    #
-    if 'inference' in sys.modules:
-      del sys.modules['inference']
-    sys.path.append(repo_version_dir)
-    self.model_type = model_type
-    self.is_instance_kind_gpu = is_instance_kind_gpu
-    logging.info(self.model_type)
-
-    # load inference parameters
-    if isinstance(inference_parameters, str):
-      self.inference_parameters = InferParamManager(json_path=inference_parameters)
-    else:
-      self.inference_parameters = InferParamManager.from_kwargs(**inference_parameters)
-      exported_file_path = os.path.join(repo_version_dir, "inference_parameters.json")
-      logging.info(f"Export inference parameters to `{exported_file_path}` when loading from dict")
-      self.inference_parameters.export(exported_file_path)
-
-    # Construct TritonPythonModel object
-    from model import TritonPythonModel
-    self.triton_python_model = TritonPythonModel()
-    self.triton_python_model.initialize(
-        dict(
-            model_repository=os.path.join(repo_version_dir, ".."),
-            model_instance_kind="GPU" if self.is_instance_kind_gpu else "cpu"))
-    # Get default config of model and model_type
-    self.default_triton_model_config = get_model_config(self.model_type).make_triton_model_config(
-        model_name=self.model_type, model_version="1", image_shape=[-1, -1])
-    # Get current model config
-    self.triton_model_config = self.triton_python_model.config_msg
-    self.input_name_to_config = {each.name: each
-                                 for each in self.triton_model_config.input}  # name: input
-    self.preprocess = {
-        k: self._get_preprocess(input)
-        for k, input in self.input_name_to_config.items()
-    }
-    # load labels
-    self._required_label_model_types = [
-        ModelTypes.visual_detector, ModelTypes.visual_classifier, ModelTypes.text_classifier,
-        ModelTypes.visual_segmenter
-    ]
-    self._output_text_models = [ModelTypes.text_to_text]
-    self.labels = []
-    if self.model_type in self._required_label_model_types:
-      with open(os.path.join(repo_version_dir, "../labels.txt"), 'r') as fp:
-        labels = fp.readlines()
-        if labels:
-          self.labels = [line for line in labels if line]
-
-  def test_triton_config(self):
-    """ test Triton config"""
-    # check if input names are still matched
-    default_input_names = [each.name for each in self.default_triton_model_config.input]
-    current_input_names = [each.name for each in self.triton_model_config.input]
-    default_input_names.sort()
-    current_input_names.sort()
-    self.assertEqual(current_input_names, default_input_names,
-                     "input name of current model vs generated model must be matched "
-                     f"{current_input_names} != {default_input_names}")
-    # check if output names are still matched
-    default_output_names = [each.name for each in self.default_triton_model_config.output]
-    current_output_names = [each.name for each in self.triton_model_config.output]
-    default_output_names.sort()
-    current_output_names.sort()
-    self.assertEqual(current_output_names, default_output_names,
-                     "output name of current model vs generated model must be matched "
-                     f"{current_output_names} not in {default_output_names}")
-
-  def test_having_labels(self):
-    if self.model_type in self._required_label_model_types:
-      self.assertTrue(
-          len(self.labels),
-          f"`labels.txt` is empty!. Model type `{self.model_type}` requires input labels in `labels.txt`"
-      )
-
-  def test_inference_with_predefined_inputs(self):
-    """ Test Inference with predefined inputs """
-
-    def _is_valid_logit(x: np.array):
-      return np.all(0 <= x) and np.all(x <= 1)
-
-    def _is_non_negative(x: np.array):
-      return np.all(x >= 0)
-
-    def _is_integer(x):
-      return np.all(np.equal(np.mod(x, 1), 0))
-
-    if len(self.input_name_to_config) == 1:
-      if "image" in self.preprocess:
-        inputs = [self.preprocess["image"](inp) for inp in PREDEFINED_IMAGES]
-      else:
-        inputs = PREDEFINED_TEXTS
-      outputs = self.triton_get_predictions(inputs)
-
-      # Test for specific model type:
-      # 1. length of output array vs config
-      # 2. type of outputs
-      # 3. test range value, shape and dtype of output
-
-      for inp, output in zip(inputs, outputs):
-
-        field = dataclasses.fields(output)[0].name
-        if self.model_type not in self._output_text_models:
-          self.assertEqual(
-              len(self.triton_model_config.output[0].dims),
-              len(getattr(output, field).shape),
-              "Length of 'dims' of config and output must be matched, but get "
-              f"Config {len(self.triton_model_config.output[0].dims)} != Output {len(getattr(output, field).shape)}"
-          )
-
-        if self.model_type == ModelTypes.visual_detector:
-          logging.info(output.predicted_labels)
-          self.assertEqual(
-              type(output), VisualDetectorOutput,
-              f"Output type must be `VisualDetectorOutput`, but got {type(output)}")
-          self.assertTrue(
-              _is_valid_logit(output.predicted_scores),
-              "`predicted_scores` must be in range [0, 1]")
-          self.assertTrue(
-              _is_non_negative(output.predicted_bboxes), "`predicted_bboxes` must be >= 0")
-          self.assertTrue(
-              np.all(0 <= output.predicted_labels) and
-              np.all(output.predicted_labels < len(self.labels)),
-              f"`predicted_labels` must be in [0, {len(self.labels) - 1}]")
-          self.assertTrue(
-              _is_integer(output.predicted_labels), "`predicted_labels` must be integer")
-
-        elif self.model_type == ModelTypes.visual_classifier:
-          self.assertEqual(
-              type(output), ClassifierOutput,
-              f"Output type must be `ClassifierOutput`, but got {type(output)}")
-          self.assertTrue(
-              _is_valid_logit(output.predicted_scores),
-              "`predicted_scores` must be in range [0, 1]")
-          if self.labels:
-            self.assertEqual(
-                len(output.predicted_scores),
-                len(self.labels),
-                f"`predicted_labels` must equal to {len(self.labels)}, however got {len(output.predicted_scores)}"
-            )
-
-        elif self.model_type == ModelTypes.text_classifier:
-          self.assertEqual(
-              type(output), ClassifierOutput,
-              f"Output type must be `ClassifierOutput`, but got {type(output)}")
-          self.assertTrue(
-              _is_valid_logit(output.predicted_scores),
-              "`predicted_scores` must be in range [0, 1]")
-          if self.labels:
-            self.assertEqual(
-                len(output.predicted_scores),
-                len(self.labels),
-                f"`predicted_labels` must equal to {len(self.labels)}, however got {len(output.predicted_scores)}"
-            )
-
-        elif self.model_type == ModelTypes.text_embedder:
-          self.assertEqual(
-              type(output), EmbeddingOutput,
-              f"Output type must be `EmbeddingOutput`, but got {type(output)}")
-          self.assertNotEqual(output.embedding_vector.shape, [])
-
-        elif self.model_type == ModelTypes.text_to_text:
-          self.assertEqual(
-              type(output), TextOutput,
-              f"Output type must be `TextOutput`, but got {type(output)}")
-
-        elif self.model_type == ModelTypes.text_to_image:
-          self.assertEqual(
-              type(output), ImageOutput,
-              f"Output type must be `ImageOutput`, but got {type(output)}")
-          self.assertTrue(_is_non_negative(output.image), "`image` elements must be >= 0")
-
-        elif self.model_type == ModelTypes.visual_embedder:
-          self.assertEqual(
-              type(output), EmbeddingOutput,
-              f"Output type must be `EmbeddingOutput`, but got {type(output)}")
-          self.assertNotEqual(output.embedding_vector.shape, [])
-
-        elif self.model_type == ModelTypes.visual_segmenter:
-          self.assertEqual(
-              type(output), MasksOutput,
-              f"Output type must be `MasksOutput`, but got {type(output)}")
-          self.assertTrue(_is_integer(output.predicted_mask), "`predicted_mask` must be integer")
-          if self.labels:
-            self.assertTrue(
-                np.all(0 <= output.predicted_mask) and
-                np.all(output.predicted_mask < len(self.labels)),
-                f"`predicted_mask` must be in [0, {len(self.labels) - 1}]")
-
-    elif len(self.input_name_to_config) == 2:
-      from itertools import zip_longest
-      if self.model_type == ModelTypes.multimodal_embedder:
-        input_images = [self.preprocess["image"](inp) for inp in PREDEFINED_IMAGES]
-        input_texts = PREDEFINED_TEXTS
-
-        def _assert(input_data):
-          batch_inputs = []
-          for group in zip_longest(*input_data.values()):
-            _input = dict(zip(input_data, group))
-            batch_inputs.append(_input)
-          outputs = self.triton_get_predictions(input_data=batch_inputs)
-          for output in outputs:
-            self.assertEqual(
-                type(output), EmbeddingOutput,
-                f"Output type must be `EmbeddingOutput`, but got {type(output)}")
-          self.assertNotEqual(output.embedding_vector.shape, [])
-
-        _assert(dict(image=input_images, text=[]))
-        _assert(dict(image=[], text=input_texts))
-
-
-if __name__ == '__main__':
-  unittest.main()

clarifai/models/model_serving/models/inference.py

@@ -1,50 +0,0 @@
-# This file contains boilerplate code to allow users write their model
-# inference code that will then interact with the Triton Inference Server
-# Python backend to serve end user requests.
-# The module name, module path, class name & get_predictions() method names MUST be maintained as is
-# but other methods may be added within the class as deemed fit provided
-# they are invoked within the main get_predictions() inference method
-# if they play a role in any step of model inference
-"""User model inference script."""
-
-import os
-from pathlib import Path
-
-from clarifai.models.model_serving.model_config import (  # noqa # pylint: disable=unused-import
-    ModelTypes, get_model_config)
-
-config = get_model_config("MODEL_TYPE_PLACEHOLDER")
-
-
-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>
-
-  @config.inference.wrap_func
-  def get_predictions(self, input_data: list, **kwargs) -> list:
-    """
-    Main model inference method.
-
-    Args:
-    -----
-      input_data: A list of input data item to predict on.
-        Input data can be an image or text, etc depending on the model type.
-
-      **kwargs: your inference parameters.
-
-    Returns:
-    --------
-      List of one of the `clarifai.models.model_serving.models.output types` or `config.inference.return_type(your_output)`. Refer to the README/docs
-    """
-
-    # Delete/Comment out line below and add your inference code
-    raise NotImplementedError()

clarifai/models/model_serving/models/test.py

@@ -1,64 +0,0 @@
-import logging
-import os
-import unittest
-
-from clarifai.models.model_serving.models.default_test import DefaultTestInferenceModel
-
-
-class CustomTestInferenceModel(DefaultTestInferenceModel):
-  """
-  Run this file to test your implementation of InferenceModel in inference.py with default tests of Triton configuration and its output values based on basic predefined inputs
-  If you want to write custom testcase or just test output value.
-  Please follow these instrucitons:
-  1. Name your test function with prefix "test" so that pytest can execute
-  2. In order to obtain output of InferenceModel, call `self.triton_get_predictions(input_data)`.
-  3. If your input is `image` and you have set custom size of it when building model repository,
-  call `self.preprocess(image)` to obtain correct resized input
-  4. Run this test by calling
-  ```bash
-  pytest ./your_triton_folder/1/test.py
-  #to see std output
-  pytest --log-cli-level=INFO  -s ./your_triton_folder/1/test.py
-  ```
-
-  ### Examples:
-  + test text-to-image output
-  ```
-  def test_text_to_image_output(self):
-    text = "Test text"
-    output = self.triton_get_predictions(text)
-    image = output.image # uint8 np.ndarray image
-    #show or save
-  ```
-  + test visual-classifier output
-  ```
-  def test_visual_classifier(self):
-    image = cv2.imread("your/local/image.jpg") # Keep in mind of format of image (BGR or RGB)
-    output = self.triton_get_predictions(image)
-    scores = output.predicted_scores # np.ndarray
-    #process scores to get class id and its score
-    logger.info(result)
-  """
-
-  # Insert your inference parameters json path here
-  # or insert a dictionary of your_parameter_name and value, e.g dict(x=1.5, y="text", c=True)
-  # or Leave it as "" if you don't have it.
-  inference_parameters = ""
-
-  ########### Initialization. Do not change it ###########
-  __test__ = True
-
-  def setUp(self) -> None:
-    logging.info("Initializing...")
-    model_type = "MODEL_TYPE_PLACEHOLDER"  # your model type
-    self.intitialize(
-        model_type,
-        repo_version_dir=os.path.dirname(__file__),
-        is_instance_kind_gpu=True,
-        inference_parameters=self.inference_parameters)
-
-  ########################################################
-
-
-if __name__ == '__main__':
-  unittest.main()

clarifai/models/model_serving/pb_model_repository.py

@@ -1,108 +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 python backend inference model controller.
-"""
-
-import inspect
-import logging
-import os
-from pathlib import Path
-from typing import Type
-
-logging.getLogger("clarifai.models.model_serving.model_config.config").setLevel(logging.ERROR)
-
-from .model_config import Serializer, TritonModelConfig  # noqa: E402
-from .models import inference, pb_model, test  # noqa: E402
-
-
-class TritonModelRepository:
-  """
-  Triton Python BE Model Repository Generator.
-  """
-
-  def __init__(self, model_config: Type[TritonModelConfig]):
-    self.model_config = model_config
-    self.config_proto = Serializer(model_config)
-
-  def _module_to_file(self, module, file_path: str, func: callable = None):
-    """
-    Write Python Module to file.
-
-    Args:
-    -----
-      module: Python module to write to file
-      file_path: Path of file to write module code into.
-      func: A function to process code of module. It contains only 1 argument, text of module. If it is None, then only save text to `file_path`
-    Returns:
-    --------
-      None
-    """
-    source_code = inspect.getsource(module)
-    with open(file_path, "w") as fp:
-      # change model type
-      if func:
-        source_code = func(source_code)
-      # write it to file
-      fp.write(source_code)
-
-  def build_repository(self, repository_dir: Path = os.curdir):
-    """
-    Generate Triton Model Repository.
-
-    Args:
-    -----
-    repository_dir: Directory to create triton model repository
-
-    Returns:
-    --------
-    None
-    """
-    model_repository = self.model_config.model_name
-    model_version = self.model_config.model_version
-    repository_path = os.path.join(repository_dir, model_repository)
-    model_version_path = os.path.join(repository_path, model_version)
-
-    if not os.path.isdir(repository_path):
-      os.mkdir(repository_path)
-      self.config_proto.to_file(repository_path)
-      for out_field in self.model_config.output:
-        #predicted int labels must have corresponding names in file
-        if hasattr(out_field, "label_filename"):
-          with open(os.path.join(repository_path, "labels.txt"), "w"):
-            pass
-        else:
-          continue
-      # gen requirements
-      with open(os.path.join(repository_path, "requirements.txt"), "w") as f:
-        f.write("clarifai>9.10.4\ntritonclient[all]")  # for model upload utils
-
-    if not os.path.isdir(model_version_path):
-      os.mkdir(model_version_path)
-    if not os.path.exists(os.path.join(model_version_path, "__init__.py")):
-      with open(os.path.join(model_version_path, "__init__.py"), "w"):
-        pass
-    # generate model.py
-    model_py_path = os.path.join(model_version_path, "model.py")
-    self._module_to_file(pb_model, model_py_path, func=None)
-
-    # generate inference.py
-    def insert_model_type_func(x):
-      return x.replace("MODEL_TYPE_PLACEHOLDER", self.model_config.model_type)
-
-    inference_py_path = os.path.join(model_version_path, "inference.py")
-    self._module_to_file(inference, inference_py_path, insert_model_type_func)
-
-    # generate test.py
-    custom_test_path = os.path.join(model_version_path, "test.py")
-    self._module_to_file(test, custom_test_path, insert_model_type_func)

clarifai-10.0.1.dist-info/RECORD

@@ -1,103 +0,0 @@
-clarifai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-clarifai/cli.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-clarifai/errors.py,sha256=RwzTajwds51wLD0MVlMC5kcpBnzRpreDLlazPSBZxrg,2605
-clarifai/versions.py,sha256=rCj3CUJhyCdprBtggBLIbWPaQXWUvrUAJoppcOb3WpM,186
-clarifai/client/__init__.py,sha256=xI1U0l5AZdRThvQAXCLsd9axxyFzXXJ22m8LHqVjQRU,662
-clarifai/client/app.py,sha256=AWUngtwF6a0uS9DInf2arz5Aa-vbxt2Ce5WSNvwlAo0,26946
-clarifai/client/base.py,sha256=A_eRK2MfnrVrcM1RXazzPmFuD0Lv2qkEPRrSR-O5Dz4,4909
-clarifai/client/dataset.py,sha256=_ADceLu9YsdfJvZtNQ3Bt3IsZM4A2W0WUFWrz02yd9I,21110
-clarifai/client/input.py,sha256=6Q_GFVNvoUd2sEpoAUwBkvRT-OCKxUmxkanXgGiQP0o,38446
-clarifai/client/lister.py,sha256=03KGMvs5RVyYqxLsSrWhNc34I8kiF1Ph0NeyEwu7nMU,2082
-clarifai/client/model.py,sha256=eOUQ2zPyqdTcYKM8_RJjdLOGJIbuRVvPQhZWtVP-quA,24619
-clarifai/client/module.py,sha256=-FVQ7fxBdcox7S3iGxHBkQuT-w6s00IysunWkLze3Y4,3766
-clarifai/client/runner.py,sha256=nP6QKs8Hy_52skr4gBNAfmPaTcYg20qzZDXnM2IxGlM,9679
-clarifai/client/search.py,sha256=pqX3BJmL8V1RKIGuNkbciDNYGoMwJj3k84B9OvpKl10,10555
-clarifai/client/user.py,sha256=6sOoHiBSHKz6zfEh4cjBbUe5CgmYs96RgHdcMmPoKys,9914
-clarifai/client/workflow.py,sha256=Oqs6X8FocwkDlnYqcvh4qxsWuleTy_-2ByCe2AmsF2M,9983
-clarifai/client/auth/__init__.py,sha256=7EwR0NrozkAUwpUnCsqXvE_p0wqx_SelXlSpKShKJK0,136
-clarifai/client/auth/helper.py,sha256=3lCKo24ZIOlcSh50juJh3ZDagOo_pxEKyoPjWUokYoA,13450
-clarifai/client/auth/register.py,sha256=2CMdBsoVLoTfjyksE6j7BM2tiEc73WKYvxnwDDgNn1k,536
-clarifai/client/auth/stub.py,sha256=KIzJZ8aRB1RzXJeWHDAx19HNdBsblPPHwYLfAkgI3rY,3779
-clarifai/constants/dataset.py,sha256=2QlHF0NMXfAdFlOpEzkNYVZcxSL-dIxq-ZsY_LsIPBA,499
-clarifai/constants/model.py,sha256=LsMkLVkuBpfS4j4yDW9M4O7HxzRpIuSo9qU5T8Wg2Co,217
-clarifai/constants/rag.py,sha256=WcHwToUVIK9ItAhDefaSohQHCLNeR55PSjZ0BFnoZ3U,28
-clarifai/constants/search.py,sha256=_g3S-JEvuygiFfMVK3cl4Ry9erZpt8Zo4ilXL2i3DAE,52
-clarifai/constants/workflow.py,sha256=cECq1xdvf44MCdtK2AbkiuuwhyL-6OWZdQfYbsLKy_o,33
-clarifai/datasets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-clarifai/datasets/export/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-clarifai/datasets/export/inputs_annotations.py,sha256=z7kmU9K5m9F5u3iEyCnuKk8Bb97kqGaixm8vJZYT554,9325
-clarifai/datasets/upload/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-clarifai/datasets/upload/base.py,sha256=IP4sdBRfThk2l0W1rDWciFrAJnKwVsM-gu4zEslJ2_E,2198
-clarifai/datasets/upload/features.py,sha256=liUMZTg0GtHRTZmfNaf7v7rAbrORAYkiN6uoaFp1rz4,1457
-clarifai/datasets/upload/image.py,sha256=oWsB0iXI1VVbxU1U2r8Q28SyjdBgrwPeQ0g65Zk-jgY,6300
-clarifai/datasets/upload/text.py,sha256=ek29V18x5LqmHqc-nmAljQcud9uRjZx8IV_lDX78zsY,1980
-clarifai/datasets/upload/utils.py,sha256=njSaRJ_OwD1k8dY9HStGpMZ9D9KFOop2qNoAs9ANx9Y,8974
-clarifai/datasets/upload/loaders/README.md,sha256=ag-3lXuvsKTZapvnqBv824rMrVeX0i9U5v1oqhdhvoo,3038
-clarifai/datasets/upload/loaders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-clarifai/datasets/upload/loaders/coco_captions.py,sha256=t-IaIXukDk1mFdeeqdwe0hLrBLuaF-cZWl2aumGUAls,1297
-clarifai/datasets/upload/loaders/coco_detection.py,sha256=dBYl2a1D7e-N1heXbFK0bImJAuq_lPQ8nxZMa1zq-Ts,2612
-clarifai/datasets/upload/loaders/coco_segmentation.py,sha256=yu9HBHYdKCllF9-6SdQ_2CaKGskE4DdeqCin7zNTN1c,3628
-clarifai/datasets/upload/loaders/imagenet_classification.py,sha256=LuylazxpI5V8fAPGCUxDirGpYMfxzRxix-MEWaCvwxI,1895
-clarifai/datasets/upload/loaders/xview_detection.py,sha256=MN8durZdDhbkczMOz8qHHodqy_0sxPw8gZeZpBAjfZo,6010
-clarifai/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-clarifai/models/api.py,sha256=d3FQQlG0mNDLrfEvchqaVcq4Tgb_TqryNnJtwp3c7sE,10961
-clarifai/models/model_serving/README.md,sha256=hxCmC_erOAto57f2pDlnYG41MTRbgZVwa1RRxoBeClQ,8367
-clarifai/models/model_serving/__init__.py,sha256=Nls28G-fedNw2oQZIkPQSN__TgjJXbG9RDzzuHIM0VI,575
-clarifai/models/model_serving/constants.py,sha256=KFASN7p9tq2JYSREGMCZ5YwS0x0Gy17lR8QrrL-z-9k,18
-clarifai/models/model_serving/pb_model_repository.py,sha256=3x3Rp22euvOaLOQbSf0KkVY5djsWc_85GX9aTSx01B4,3764
-clarifai/models/model_serving/cli/__init__.py,sha256=Nls28G-fedNw2oQZIkPQSN__TgjJXbG9RDzzuHIM0VI,575
-clarifai/models/model_serving/cli/deploy_cli.py,sha256=lDp_hZdHLAo7IWlin9v5CtNuhkKvu5ucTGDzmf3bkE0,4376
-clarifai/models/model_serving/cli/model_zip.py,sha256=TVaHP_4l-WtRn9QJBkhZ7EzaSV9qyhyOUN_h2niNEeE,1866
-clarifai/models/model_serving/cli/repository.py,sha256=EJiatCJfBiZ4Z9AYmyBjagBM8fT-iVeD2_Wwh8S7kQ0,2962
-clarifai/models/model_serving/docs/custom_config.md,sha256=W1mMIRCI4dVP0czvq5fxOLq1hv0PCBMFRvtZtQwz8kU,1522
-clarifai/models/model_serving/docs/dependencies.md,sha256=R9zyE2MbW98DsvFY2ABm4fik0fMPERxrQkhMKMDKpY4,721
-clarifai/models/model_serving/docs/inference_parameters.md,sha256=GWEulNgLICR2q9Nd3UtfAFtrCXOEaW5fyXWdCUJJTq8,4270
-clarifai/models/model_serving/docs/model_types.md,sha256=R1bCGo-i9FBXHpVP57OnTUZxLlcBuJW7V5X6WcLHMUg,1067
-clarifai/models/model_serving/docs/output.md,sha256=IFpwcwhEs7zjIxSDvtYFdmwXVwWal1s5yc-3ohyJEe4,2163
-clarifai/models/model_serving/model_config/__init__.py,sha256=wNmIBwhgQaYlVNKYdDqBgbgdnfP4e9vtqKoDbL4cf34,712
-clarifai/models/model_serving/model_config/config.py,sha256=uwer6SWddknz-Dhocr49i_vBCiUcgv9vW9epU__hX8E,8186
-clarifai/models/model_serving/model_config/inference_parameter.py,sha256=JdrPpEOfbLXXDeEVnlshFC49RdnShGLQ5nmETSFUbWw,3754
-clarifai/models/model_serving/model_config/serializer.py,sha256=d-5liwQ7cOZ1maNKPsX7OZL76_O3YTwbJ7K4E5RwYwI,4226
-clarifai/models/model_serving/model_config/model_types_config/multimodal-embedder.yaml,sha256=TMsEv9RYiafHyvzvQ8cWx3qECvPtilcKDrKJxtzTQOE,475
-clarifai/models/model_serving/model_config/model_types_config/text-classifier.yaml,sha256=zX2CGlyZr0Pg4eIEs3Du-Ymk14fSaMBZUFWVRcNGEm8,358
-clarifai/models/model_serving/model_config/model_types_config/text-embedder.yaml,sha256=JUqKZOR10GhcnBTGNwYYtlO5omhsRrt1N-b7DCBlnfs,340
-clarifai/models/model_serving/model_config/model_types_config/text-to-image.yaml,sha256=GepiAaDqSnfEMBoX6oJxgqHefbuUyQGE0RhvfBvnVW8,329
-clarifai/models/model_serving/model_config/model_types_config/text-to-text.yaml,sha256=-224qTe32EadryifTPykwQouRsaLT-juwxzzv4Bnvw8,317
-clarifai/models/model_serving/model_config/model_types_config/visual-classifier.yaml,sha256=vcqcPkJUt-q10UljxW6p4L2gfSOCiMipOPnCiCyausE,370
-clarifai/models/model_serving/model_config/model_types_config/visual-detector.yaml,sha256=gqM7jR1Z1RCuGn3M4eGqs3viIjwaD88_L6t7wlSjB2I,720
-clarifai/models/model_serving/model_config/model_types_config/visual-embedder.yaml,sha256=-kWXlM7m2DBSWcjBF1PWThKTXr8pE1eh8vuml0uBB3o,352
-clarifai/models/model_serving/model_config/model_types_config/visual-segmenter.yaml,sha256=3sG07bc6j8Sbxeos8dU0cJH16ZFDkYd9FGkwXiIVyXc,411
-clarifai/models/model_serving/models/__init__.py,sha256=Nls28G-fedNw2oQZIkPQSN__TgjJXbG9RDzzuHIM0VI,575
-clarifai/models/model_serving/models/default_test.py,sha256=fQ_LSrU8WhxTb0uBV2fWp2VaqZevPPdW-rZ0fDuM8lI,11559
-clarifai/models/model_serving/models/inference.py,sha256=wqWOZedNdTgPXZE9kFXpyn7wg_21h-cjUOnsrBgXGak,1892
-clarifai/models/model_serving/models/model_types.py,sha256=owGtG7lBd2CXCnm_4KXv0umjSiWt34X9JJWm97tbzmY,8636
-clarifai/models/model_serving/models/output.py,sha256=qWlVRxFpqHjlTrrj7Ze3vMniBgqkZhbW1NgX7zNgkfI,3966
-clarifai/models/model_serving/models/pb_model.py,sha256=TJJWY-ExATL4M58gYQTI6vAHgY9OCaOjympeZtGdRj8,2533
-clarifai/models/model_serving/models/test.py,sha256=0FV2yzv1g-yOlvcHDiI6QL89ULMmx04_euXO3ZjkTb0,2280
-clarifai/modules/README.md,sha256=mx8pVx6cPp-pP4LcFPT_nX3ngGmhygVK0WiXeD3cbIo,367
-clarifai/modules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-clarifai/modules/css.py,sha256=kadCEunmyh5h2yf0-4aysE3ZcZ6qaQcxuAgDXS96yF8,2020
-clarifai/modules/pages.py,sha256=iOoM3RNRMgXlV0qBqcdQofxoXo2RuRQh0h9c9BIS0-I,1383
-clarifai/modules/style.css,sha256=j7FNPZVhLPj35vvBksAJ90RuX5sLuqzDR5iM2WIEhiA,6073
-clarifai/rag/__init__.py,sha256=wu3PzAzo7uqgrEzuaC9lY_3gj1HFiR3GU3elZIKTT5g,40
-clarifai/rag/rag.py,sha256=ZtaV-d4_ztqACzyrkvWq8ZOmcYkYzoYggtehdjCqUOw,10117
-clarifai/rag/utils.py,sha256=lQ9dYd_FlVSuNwa3d18-niIyy_tzhYz2Pr8vB2pUrIQ,3380
-clarifai/runners/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-clarifai/runners/example.py,sha256=V0Nc52JkhCm97oaWzKVg71g50M1ltxI9jyPMo6tKU6E,1302
-clarifai/runners/example_llama2.py,sha256=WMGTqv3v9t3ID1rjW9BTLMkIuvyTESL6xHcOO6A220Y,2712
-clarifai/schema/search.py,sha256=JjTi8ammJgZZ2OGl4K6tIA4zEJ1Fr2ASZARXavI1j5c,2448
-clarifai/urls/helper.py,sha256=tjoMGGHuWX68DUB0pk4MEjrmFsClUAQj2jmVEM_Sy78,4751
-clarifai/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-clarifai/utils/logging.py,sha256=fO0VqJJUZKToKevgKWGZKvqsU9hCDMQTBMzIYtKQnH8,3323
-clarifai/utils/misc.py,sha256=cC_j0eEsJ8bfnj0oRd2z-Rms1mQbAfLwrSs07hwQuCE,1420
-clarifai/utils/model_train.py,sha256=v4-bsPOOi-jxzwDxdNf2exaWPEpKD7BYcc6w0kMds4o,7832
-clarifai/workflows/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-clarifai/workflows/export.py,sha256=vICRhIreqDSShxLKjHNM2JwzKsf1B4fdXB0ciMcA70k,1945
-clarifai/workflows/utils.py,sha256=nGeB_yjVgUO9kOeKTg4OBBaBz-AwXI3m-huSVj-9W18,1924
-clarifai/workflows/validate.py,sha256=iCEKBTtB-57uE3LVU7D4AI9BRHxIxahk3U1Ro08HP-o,2535
-clarifai-10.0.1.dist-info/LICENSE,sha256=mUqF_d12-qE2n41g7C5_sq-BMLOcj6CNN-jevr15YHU,555
-clarifai-10.0.1.dist-info/METADATA,sha256=ff_NiIDsxqOph3Xf9TXed59WJaMaBjG5j-9xzhiY7-M,16510
-clarifai-10.0.1.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-clarifai-10.0.1.dist-info/entry_points.txt,sha256=cna1vVlFIZZZlxHy1AbhooFGy-dw1W2xRfbOVRSWSKg,255
-clarifai-10.0.1.dist-info/top_level.txt,sha256=wUMdCQGjkxaynZ6nZ9FAnvBUCgp5RJUVFSy2j-KYo0s,9
-clarifai-10.0.1.dist-info/RECORD,,

clarifai-10.0.1.dist-info/entry_points.txt

@@ -1,4 +0,0 @@
-[console_scripts]
-clarifai-model-upload-init = clarifai.models.model_serving.cli.repository:model_upload_init
-clarifai-triton-zip = clarifai.models.model_serving.cli.model_zip:main
-clarifai-upload-model = clarifai.models.model_serving.cli.deploy_cli:main