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

clarifai_utils/models/model_serving/models/model_types.py

@@ -1,265 +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.
-"""
-Parse inference model predictions to triton inference responses
-per model type.
-"""
-
-from functools import wraps
-from itertools import zip_longest
-from typing import Callable, Dict
-import numpy as np
-
-try:
-  import triton_python_backend_utils as pb_utils
-except ModuleNotFoundError:
-  pass
-
-
-def visual_detector(func: Callable):
-  """
-  Visual detector type output parser.
-  """
-
-  @wraps(func)
-  def parse_predictions(self, input_data: np.ndarray, *args, **kwargs):
-    """
-    Format predictions and return clarifai compatible output.
-    """
-    out_bboxes = []
-    out_labels = []
-    out_scores = []
-    for item in input_data:
-      preds = func(self, item, *args, **kwargs)
-      out_bboxes.append(preds.predicted_bboxes)
-      out_labels.append(preds.predicted_labels)
-      out_scores.append(preds.predicted_scores)
-
-    if len(out_bboxes) < 1 or len(out_labels) < 1:
-      out_tensor_bboxes = pb_utils.Tensor("predicted_bboxes", np.zeros((0, 4), dtype=np.float32))
-      out_tensor_labels = pb_utils.Tensor("predicted_labels", np.zeros((0, 1), dtype=np.int32))
-      out_tensor_scores = pb_utils.Tensor("predicted_scores", np.zeros((0, 1), dtype=np.float32))
-    else:
-      out_tensor_bboxes = pb_utils.Tensor("predicted_bboxes",
-                                          np.asarray(out_bboxes, dtype=np.float32))
-      out_tensor_labels = pb_utils.Tensor("predicted_labels",
-                                          np.asarray(out_labels, dtype=np.int32))
-      out_tensor_scores = pb_utils.Tensor("predicted_scores",
-                                          np.asarray(out_scores, dtype=np.float32))
-
-    inference_response = pb_utils.InferenceResponse(
-        output_tensors=[out_tensor_bboxes, out_tensor_labels, out_tensor_scores])
-
-    return inference_response
-
-  return parse_predictions
-
-
-def visual_classifier(func: Callable):
-  """
-  Visual classifier type output parser.
-  """
-
-  @wraps(func)
-  def parse_predictions(self, input_data: np.ndarray, *args, **kwargs):
-    """
-    Format predictions and return clarifai compatible output.
-    """
-    out_scores = []
-    for item in input_data:
-      preds = func(self, item, *args, **kwargs)
-      out_scores.append(preds.predicted_scores)
-
-    out_tensor_scores = pb_utils.Tensor("softmax_predictions",
-                                        np.asarray(out_scores, dtype=np.float32))
-    inference_response = pb_utils.InferenceResponse(output_tensors=[out_tensor_scores])
-
-    return inference_response
-
-  return parse_predictions
-
-
-def text_classifier(func: Callable):
-  """
-  Text classifier type output parser.
-  """
-
-  @wraps(func)
-  def parse_predictions(self, input_data: np.ndarray, *args, **kwargs):
-    """
-    Format predictions and return clarifai compatible output.
-    """
-    out_scores = []
-    input_data = [in_elem[0].decode() for in_elem in input_data]
-    for item in input_data:
-      preds = func(self, item, *args, **kwargs)
-      out_scores.append(preds.predicted_scores)
-
-    out_tensor_scores = pb_utils.Tensor("softmax_predictions",
-                                        np.asarray(out_scores, dtype=np.float32))
-    inference_response = pb_utils.InferenceResponse(output_tensors=[out_tensor_scores])
-
-    return inference_response
-
-  return parse_predictions
-
-
-def text_to_text(func: Callable):
-  """
-  Text to text type output parser.
-  Convert a sequence of text into another e.g. text generation,
-  summarization or translation.
-  """
-
-  @wraps(func)
-  def parse_predictions(self, input_data: np.ndarray, *args, **kwargs):
-    """
-    Format predictions and return clarifai compatible output.
-    """
-    out_text = []
-    input_data = [in_elem[0].decode() for in_elem in input_data]
-    for item in input_data:
-      preds = func(self, item, *args, **kwargs)
-      out_text.append(preds.predicted_text)
-
-    out_text_tensor = pb_utils.Tensor("text", np.asarray(out_text, dtype=object))
-    inference_response = pb_utils.InferenceResponse(output_tensors=[out_text_tensor])
-
-    return inference_response
-
-  return parse_predictions
-
-
-def text_embedder(func: Callable):
-  """
-  Text embedder type output parser.
-  Generates embeddings for an input text.
-  """
-
-  @wraps(func)
-  def parse_predictions(self, input_data: np.ndarray, *args, **kwargs):
-    """
-    Format predictions and return clarifai compatible output.
-    """
-    out_embeddings = []
-    input_data = [in_elem[0].decode() for in_elem in input_data]
-    for item in input_data:
-      preds = func(self, item, *args, **kwargs)
-      out_embeddings.append(preds.embedding_vector)
-
-    out_embed_tensor = pb_utils.Tensor("embeddings", np.asarray(out_embeddings, dtype=np.float32))
-    inference_response = pb_utils.InferenceResponse(output_tensors=[out_embed_tensor])
-
-    return inference_response
-
-  return parse_predictions
-
-
-def visual_embedder(func: Callable):
-  """
-  Visual embedder type output parser.
-  Generates embeddings for an input image.
-  """
-
-  @wraps(func)
-  def parse_predictions(self, input_data: np.ndarray, *args, **kwargs):
-    """
-    Format predictions and return clarifai compatible output.
-    """
-    out_embeddings = []
-    for item in input_data:
-      preds = func(self, item, *args, **kwargs)
-      out_embeddings.append(preds.embedding_vector)
-
-    out_embed_tensor = pb_utils.Tensor("embeddings", np.asarray(out_embeddings, dtype=np.float32))
-    inference_response = pb_utils.InferenceResponse(output_tensors=[out_embed_tensor])
-
-    return inference_response
-
-  return parse_predictions
-
-
-def visual_segmenter(func: Callable):
-  """
-  Visual segmenter type output parser.
-  """
-
-  @wraps(func)
-  def parse_predictions(self, input_data: np.ndarray, *args, **kwargs):
-    """
-    Format predictions and return clarifai compatible output.
-    """
-    masks = []
-    for item in input_data:
-      preds = func(self, item, *args, **kwargs)
-      masks.append(preds.predicted_mask)
-
-    out_mask_tensor = pb_utils.Tensor("predicted_mask", np.asarray(masks, dtype=np.int64))
-    inference_response = pb_utils.InferenceResponse(output_tensors=[out_mask_tensor])
-
-    return inference_response
-
-  return parse_predictions
-
-
-def text_to_image(func: Callable):
-  """
-  Text to image type output parser.
-  """
-
-  @wraps(func)
-  def parse_predictions(self, input_data: np.ndarray, *args, **kwargs):
-    """
-    Format predictions and return clarifai compatible output.
-    """
-    gen_images = []
-    input_data = [in_elem[0].decode() for in_elem in input_data]
-    for item in input_data:
-      preds = func(self, item, *args, **kwargs)
-      gen_images.append(preds.image)
-
-    out_image_tensor = pb_utils.Tensor("image", np.asarray(gen_images, dtype=np.uint8))
-    inference_response = pb_utils.InferenceResponse(output_tensors=[out_image_tensor])
-
-    return inference_response
-
-  return parse_predictions
-
-
-def multimodal_embedder(func: Callable):
-  """
-  Multimodal embedder type output parser.
-  Generates embeddings for image or text input.
-  """
-
-  @wraps(func)
-  def parse_predictions(self, input_data: Dict[str, np.ndarray], *args, **kwargs):
-    """
-    Format predictions and return clarifai compatible output.
-    """
-    out_embeddings = []
-    for group in zip_longest(*input_data.values()):
-      _input_data = dict(zip(input_data, group))
-      for k, v in _input_data.items():
-        # decode np.object to string
-        if isinstance(v, np.ndarray) and v.dtype == np.object_:
-          _input_data.update({k: v[0].decode()})
-      preds = func(self, _input_data, *args, **kwargs)
-      out_embeddings.append(preds.embedding_vector)
-
-    out_embed_tensor = pb_utils.Tensor("embeddings", np.asarray(out_embeddings, dtype=np.float32))
-    inference_response = pb_utils.InferenceResponse(output_tensors=[out_embed_tensor])
-
-    return inference_response
-
-  return parse_predictions

clarifai_utils/models/model_serving/models/output.py

@@ -1,124 +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.
-"""
-Output Predictions format for different model types.
-"""
-
-from dataclasses import dataclass
-import numpy as np
-
-
-@dataclass
-class VisualDetectorOutput:
-  predicted_bboxes: np.ndarray
-  predicted_labels: np.ndarray
-  predicted_scores: np.ndarray
-
-  def __post_init__(self):
-    """
-    Validate input upon initialization.
-    """
-    assert self.predicted_bboxes.ndim == self.predicted_labels.ndim == \
-      self.predicted_scores.ndim==2, f"All predictions must be 2-dimensional, \
-        Got bbox-dims: {self.predicted_bboxes.ndim}, label-dims: {self.predicted_labels.ndim}, \
-          scores-dims: {self.predicted_scores.ndim} instead."
-    assert self.predicted_bboxes.shape[0] == self.predicted_labels.shape[0] == \
-      self.predicted_scores.shape[0], f"The Number of predicted bounding boxes, \
-        predicted labels and predicted scores MUST match. Got {len(self.predicted_bboxes)}, \
-          {self.predicted_labels.shape[0]}, {self.predicted_scores.shape[0]} instead."
-
-    if len(self.predicted_labels) > 0:
-      assert self.predicted_bboxes.shape[
-          1] == 4, f"Box coordinates must have a length of 4. Actual:{self.predicted_bboxes.shape[1]}"
-      assert np.all(np.logical_and(0 <= self.predicted_bboxes, self.predicted_bboxes <= 1)), \
-       "Bounding box coordinates must be between 0 and 1"
-
-
-@dataclass
-class ClassifierOutput:
-  """
-  Takes model softmax predictions
-  """
-  predicted_scores: np.ndarray
-
-  # the index of each predicted score as returned by the model must correspond
-  # to the predicted label index in the labels.txt file
-
-  def __post_init__(self):
-    """
-    Validate input upon initialization.
-    """
-    assert self.predicted_scores.ndim == 1, \
-      f"All predictions must be 1-dimensional, Got scores-dims: {self.predicted_scores.ndim} instead."
-
-
-@dataclass
-class TextOutput:
-  """
-  Takes model text predictions
-  """
-  predicted_text: np.ndarray
-
-  def __post_init__(self):
-    """
-    Validate input upon initialization.
-    """
-    assert self.predicted_text.ndim == 0, \
-      f"All predictions must be 0-dimensional, Got text-dims: {self.predicted_text.ndim} instead."
-
-
-@dataclass
-class EmbeddingOutput:
-  """
-  Takes embedding vector returned by a model.
-  """
-  embedding_vector: np.ndarray
-
-  def __post_init__(self):
-    """
-    Validate input upon initialization.
-    """
-    assert self.embedding_vector.ndim == 1, \
-      f"Embeddings must be 1-dimensional, Got embedding-dims: {self.embedding_vector.ndim} instead."
-
-
-@dataclass
-class MasksOutput:
-  """
-  Takes image segmentation masks returned by a model.
-  """
-  predicted_mask: np.ndarray
-
-  def __post_init__(self):
-    """
-    Validate input upon initialization.
-    """
-    assert self.predicted_mask.ndim == 2, \
-      f"predicted_mask must be 2-dimensional, Got mask dims: {self.predicted_mask.ndim} instead."
-
-
-@dataclass
-class ImageOutput:
-  """
-  Takes a predicted/generated image array as returned by a model.
-  """
-  image: np.ndarray
-
-  def __post_init__(self):
-    """
-    Validate input upon initialization.
-    """
-    assert self.image.ndim == 3, \
-      f"Generated image must be 3-dimensional, Got image-dims: {self.image.ndim} instead."
-    assert self.image.shape[2] == 3, \
-      f"The image channels dimension must equal 3, Got channel dim: {self.image.shape[2]} instead."

clarifai_utils/models/model_serving/models/pb_model.py

@@ -1,74 +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 inference server Python Backend Model."""
-
-import os
-import sys
-
-try:
-  import triton_python_backend_utils as pb_utils
-except ModuleNotFoundError:
-  pass
-from google.protobuf import text_format
-from tritonclient.grpc.model_config_pb2 import ModelConfig
-from clarifai.models.model_serving.model_config.inference_parameter import parse_req_parameters
-
-
-class TritonPythonModel:
-  """
-  Triton Python BE Model.
-  """
-
-  def initialize(self, args):
-    """
-    Triton server init.
-    """
-    args["model_repository"] = args["model_repository"].replace("/1/model.py", "")
-    sys.path.append(os.path.dirname(__file__))
-    from inference import InferenceModel
-
-    self.inference_obj = InferenceModel()
-
-    # Read input_name from config file
-    self.config_msg = ModelConfig()
-    with open(os.path.join(args["model_repository"], "config.pbtxt"), "r") as f:
-      cfg = f.read()
-    text_format.Merge(cfg, self.config_msg)
-    self.input_names = [inp.name for inp in self.config_msg.input]
-
-  def execute(self, requests):
-    """
-    Serve model inference requests.
-    """
-    responses = []
-
-    for request in requests:
-      parameters = request.parameters()
-      parameters = parse_req_parameters(parameters) if parameters else {}
-
-      if len(self.input_names) == 1:
-        in_batch = pb_utils.get_input_tensor_by_name(request, self.input_names[0])
-        in_batch = in_batch.as_numpy()
-        inference_response = self.inference_obj.get_predictions(in_batch, **parameters)
-      else:
-        multi_in_batch_dict = {}
-        for input_name in self.input_names:
-          in_batch = pb_utils.get_input_tensor_by_name(request, input_name)
-          in_batch = in_batch.as_numpy() if in_batch is not None else []
-          multi_in_batch_dict.update({input_name: in_batch})
-
-        inference_response = self.inference_obj.get_predictions(multi_in_batch_dict, **parameters)
-
-      responses.append(inference_response)
-
-    return responses

clarifai_utils/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 = "clarifai-model-type"  # 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_utils/models/model_serving/pb_model_repository.py

@@ -1,101 +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 os
-from pathlib import Path
-from typing import Callable, Type
-
-from .model_config import Serializer, TritonModelConfig
-from .models import inference, pb_model, test
-
-
-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_name: Callable, filename: str, destination_dir: str) -> None:
-    """
-    Write Python Module to file.
-
-    Args:
-    -----
-    module_name: Python module name to write to file
-    filename: Name of the file to write to destination_dir
-    destination_dir: Directory to save the generated triton model file.
-
-    Returns:
-    --------
-    None
-    """
-    module_path: Path = os.path.join(destination_dir, filename)
-    source_code = inspect.getsource(module_name)
-    with open(module_path, "w") as pb_model:
-      pb_model.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.5.3\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 & inference.py modules
-    self._module_to_file(pb_model, filename="model.py", destination_dir=model_version_path)
-    self._module_to_file(inference, filename="inference.py", destination_dir=model_version_path)
-    # generate test.py
-    custom_test_path = os.path.join(model_version_path, "test.py")
-    test_source_code = inspect.getsource(test)
-    with open(custom_test_path, "w") as fp:
-      # change model type
-      test_source_code = test_source_code.replace("clarifai-model-type",
-                                                  self.model_config.model_type)
-      # write it to file
-      fp.write(test_source_code)

clarifai_utils/modules/README.md

@@ -1,5 +0,0 @@
-# Module Utils
-
-Additional helper functions for creating Clarifai Modules should be placed here so that they can be reused across modules.
-
-This should still not import streamlit as we want to keep clarifai-python-utils lightweight. If you find we need utilities for streamlit itself we should start a new repo for that. Please contact support@clarifai.com to do so.

clarifai_utils/modules/css.py

@@ -1,60 +0,0 @@
-import os
-
-
-class ClarifaiStreamlitCSS(object):
-  """ ClarifaiStreamlitCSS helps get a consistent style by default for Clarifai provided
-  streamlit apps.
-  """
-
-  @classmethod
-  def insert_default_css(cls, st):
-    """ Inserts the default style provided in style.css in this folder into the streamlit page
-
-    Example:
-      ClarifaiStreamlitCSS.insert_default_css()
-
-    Note:
-      This must be placed in both the app.py AND all the pages/*.py files to get the custom styles.
-    """
-    file_name = os.path.join(os.path.dirname(__file__), "style.css")
-    cls.insert_css_file(file_name, st)
-
-  @classmethod
-  def insert_css_file(cls, css_file, st):
-    """ Open the full filename to the css file and insert it's contents the style of the page.
-    """
-    with open(css_file) as f:
-      st.markdown(f'<style>{f.read()}</style>', unsafe_allow_html=True)
-
-  @classmethod
-  def buttonlink(cls, st, label, link, target="_parent", style=""):
-    """
-    This is a streamlit button that will link to another page (or _self if target is _self).
-    It is styled to look like the other stButton>button buttons that are created with st.button().
-
-    You must insert_default_css(st) before using on a page.
-
-    Example:
-      ClarifaiStreamlitCSS.insert_default_css(st)
-      cols = st.columns(4)
-      ClarifaiStreamlitCSS.buttonlink(cols[3], "Button", "https://clarifai.com", "_blank")
-
-    Args:
-      st: the streamlit package.
-      label: the text string to display in the button.
-      link: the url to link the button to.
-      target: to open the link in same page (_parent) or new tab (_blank).
-      style: additional style to apply to the button link.
-        Ex: "background-color: rgb(45, 164, 78); color:white;" makes the button green background with white text.
-    """
-    astyle = ""
-    if style:
-      astyle = f'style="{style}"'
-
-    st.markdown(
-        f'''
-    <div class="stButton">
-      <a href="{link}" target="{target}" {astyle}>{label}</a>
-    </div>
-    ''',
-        unsafe_allow_html=True)