clarifai 11.6.4rc2__py3-none-any.whl → 11.6.5__py3-none-any.whl

clarifai/models/model_serving/repo_build/static_files/sample_clarifai_config.yaml

@@ -1,25 +0,0 @@
-# Sample config of inference_parameters and labels
-# For detail, please refer to docs
-# --------------------
-# inference_parameters:
-#   - path: boolean_var
-#     default_value: true
-#     field_type: 1
-#     description: a boolean variable
-#   - path: string_var
-#     default_value: "a string"
-#     field_type: 2
-#     description: a string variable
-#   - path: number_var
-#     default_value: 1
-#     field_type: 3
-#     description: a number variable
-#   - path: secret_string_var
-#     default_value: "YOUR_SECRET"
-#     field_type: 21
-#     description: a string variable contains secret like API key
-# labels:
-#   - concept1
-#   - concept2
-#   - concept3
-#   - concept4

clarifai/models/model_serving/repo_build/static_files/test.py

@@ -1,40 +0,0 @@
-import unittest
-
-from clarifai.models.model_serving.repo_build import BaseTest
-
-
-class CustomTest(unittest.TestCase):
-  """
-  BaseTest loads the InferenceModel from the inference.py file in the current working directory.
-  To execute the predict method of the InferenceModel, use the predict method in BaseTest.
-  It takes the exact same inputs and inference parameters, returning the same outputs as InferenceModel.predict.
-  The difference is that BaseTest.predict verifies your_infer_parameters against config.clarifai_models.inference_parameters and checks the output values.
-
-  For example, test input value of visual-classifier
-
-  def test_input(self):
-    import cv2
-    path = "path/to/image"
-    img = cv2.imread(path)
-    outputs = self.model.predict([img], infer_param1=..., infer_param2=...)
-    print(outputs)
-    assert outputs
-
-  """
-
-  def setUp(self) -> None:
-    your_infer_parameter = dict(
-    )  # for example dict(float_var=0.12, string_var="test", _secret_string_var="secret")
-    self.model = BaseTest(your_infer_parameter)
-
-  def test_default_cases(self):
-    """Test your model with dummy inputs.
-    In general, you only need to run this test to check your InferneceModel implementation.
-    In case the default inputs makes your model failed for some reason (not because of assert in `test_with_default_inputs`),
-    you can comment out this test.
-    """
-    self.model.test_with_default_inputs()
-
-  def test_specific_case1(self):
-    """ Implement your test case"""
-    pass

clarifai/models/model_serving/repo_build/static_files/triton/model.py

@@ -1,75 +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 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.
-    """
-    sys.path.append(os.path.dirname(__file__))
-    from inference import InferenceModel
-
-    self.inference_obj = InferenceModel()
-
-    # Read input_name from config file
-    self.input_names = [inp.name for inp in self.inference_obj.config.serving_backend.triton.input]
-
-  def execute(self, requests):
-    """
-    Serve model inference requests.
-    """
-    responses = []
-
-    for request in requests:
-      try:
-        parameters = request.parameters()
-      except Exception:
-        print(
-            "It seems this triton version does not support `parameters()` in request. "
-            "Please upgrade tritonserver version otherwise can not use `inference_parameters`. Error message: {e}"
-        )
-        parameters = None
-
-      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()
-        data = in_batch
-      else:
-        data = {}
-        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 []
-          data.update({input_name: in_batch})
-
-      inference_response = self.inference_obj._tritonserver_predict(
-          input_data=data, inference_parameters=parameters)
-      responses.append(inference_response)
-
-    return responses

clarifai/models/model_serving/utils.py

@@ -1,23 +0,0 @@
-import os
-
-from .constants import CLARIFAI_PAT_PATH
-
-
-def _persist_pat(pat: str):
-  """ Write down pat to CLARIFAI_PAT_PATH """
-  with open(CLARIFAI_PAT_PATH, "w") as f:
-    f.write(pat)
-
-
-def _read_pat():
-  if not os.path.exists(CLARIFAI_PAT_PATH):
-    return None
-  with open(CLARIFAI_PAT_PATH, "r") as f:
-    return f.read().replace("\n", "").replace("\r", "").strip()
-
-
-def login(pat=None):
-  """ if pat provided, set pat to CLARIFAI_PAT otherwise read pat from file"""
-  pat = pat or _read_pat()
-  assert pat, Exception("PAT is not found, please run `clarifai login` to persist your PAT")
-  os.environ["CLARIFAI_PAT"] = pat

clarifai/runners/models/base_typed_model.py

@@ -1,238 +0,0 @@
-import itertools
-from typing import Any, Dict, Iterator, List, Tuple
-
-import numpy as np
-from clarifai_grpc.grpc.api import resources_pb2, service_pb2
-from clarifai_grpc.grpc.api.service_pb2 import PostModelOutputsRequest
-from google.protobuf import json_format
-
-from ..utils.data_handler import InputDataHandler, OutputDataHandler
-from .model_runner import ModelRunner
-
-
-class AnyAnyModel(ModelRunner):
-
-  def load_model(self):
-    """
-    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.
-    """
-    raise NotImplementedError
-
-  def parse_input_request(
-      self, input_request: service_pb2.PostModelOutputsRequest) -> Tuple[List[Dict], Dict]:
-    list_input_dict = [
-        InputDataHandler.from_proto(input).to_python() for input in input_request.inputs
-    ]
-    inference_params = json_format.MessageToDict(
-        input_request.model.model_version.output_info.params)
-
-    return list_input_dict, inference_params
-
-  def convert_output_to_proto(self, outputs: list):
-    assert (isinstance(outputs, Iterator) or isinstance(outputs, list) or
-            isinstance(outputs, tuple)), "outputs must be an Iterator"
-    output_protos = []
-    for output in outputs:
-      if isinstance(output, OutputDataHandler):
-        output = output.proto
-      elif isinstance(output, resources_pb2.Output):
-        pass
-      else:
-        raise NotImplementedError
-      output_protos.append(output)
-
-    return service_pb2.MultiOutputResponse(outputs=output_protos)
-
-  def predict_wrapper(
-      self, request: service_pb2.PostModelOutputsRequest) -> service_pb2.MultiOutputResponse:
-    list_dict_input, inference_params = self.parse_input_request(request)
-    outputs = self.predict(list_dict_input, inference_parameters=inference_params)
-    return self.convert_output_to_proto(outputs)
-
-  def generate_wrapper(
-      self, request: PostModelOutputsRequest) -> Iterator[service_pb2.MultiOutputResponse]:
-    list_dict_input, inference_params = self.parse_input_request(request)
-    outputs = self.generate(list_dict_input, inference_parameters=inference_params)
-    for output in outputs:
-      yield self.convert_output_to_proto(output)
-
-  def _preprocess_stream(
-      self, request: Iterator[PostModelOutputsRequest]) -> Iterator[Tuple[List[Dict], List[Dict]]]:
-    """Return generator of processed data (from proto to python) and inference parameters like predict and generate"""
-    for i, req in enumerate(request):
-      input_data, _ = self.parse_input_request(req)
-      yield input_data
-
-  def stream_wrapper(self, request: Iterator[PostModelOutputsRequest]
-                    ) -> Iterator[service_pb2.MultiOutputResponse]:
-    first_request = next(request)
-    _, inference_params = self.parse_input_request(first_request)
-    request_iterator = itertools.chain([first_request], request)
-    outputs = self.stream(self._preprocess_stream(request_iterator), inference_params)
-    for output in outputs:
-      yield self.convert_output_to_proto(output)
-
-  def predict(self, input_data: List[Dict],
-              inference_parameters: Dict[str, Any] = {}) -> List[OutputDataHandler]:
-    """
-    Prediction method.
-
-    Args:
-    -----
-    - input_data: is list of dict where key is input type name.
-      * image: np.ndarray
-      * text: str
-      * audio: bytes
-
-    - inference_parameters (Dict[str, Union[bool, str, float, int]]): your inference parameters.
-
-    Returns:
-    --------
-      List of OutputDataHandler
-    """
-    raise NotImplementedError
-
-  def generate(self, input_data: List[Dict],
-               inference_parameters: Dict[str, Any] = {}) -> Iterator[List[OutputDataHandler]]:
-    """
-    Generate method.
-
-    Args:
-    -----
-    - input_data: is list of dict where key is input type name.
-      * image: np.ndarray
-      * text: str
-      * audio: bytes
-
-    - inference_parameters (Dict[str, Union[bool, str, float, int]]): your inference parameters.
-
-    Yield:
-    --------
-      List of OutputDataHandler
-    """
-    raise NotImplementedError
-
-  def stream(self, inputs: Iterator[List[Dict[str, Any]]],
-             inference_params: Dict[str, Any]) -> Iterator[List[OutputDataHandler]]:
-    """
-    Stream method.
-
-    Args:
-    -----
-    input_request: is an Iterator of Tuple which
-    - First element (List[Dict[str, Union[np.ndarray, str, bytes]]]) is list of dict input data type which keys and values are:
-        * image: np.ndarray
-        * text: str
-        * audio: bytes
-
-    - Second element (Dict[str, Union[bool, str, float, int]]): is a dict of inference_parameters
-
-    Yield:
-    --------
-      List of OutputDataHandler
-    """
-    raise NotImplementedError
-
-
-class VisualInputModel(AnyAnyModel):
-
-  def parse_input_request(
-      self, input_request: service_pb2.PostModelOutputsRequest) -> Tuple[List[Dict], Dict]:
-    list_input_dict = [
-        InputDataHandler.from_proto(input).image(format="np") for input in input_request.inputs
-    ]
-    inference_params = json_format.MessageToDict(
-        input_request.model.model_version.output_info.params)
-
-    return list_input_dict, inference_params
-
-  def load_model(self):
-    """
-    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.
-    """
-    raise NotImplementedError
-
-  def predict(self, input_data: List[np.ndarray],
-              inference_parameters: Dict[str, Any] = {}) -> List[OutputDataHandler]:
-    """
-    Prediction method.
-
-    Args:
-    -----
-    - input_data(List[np.ndarray]): is list of image as np.ndarray type
-    - inference_parameters (Dict[str, Union[bool, str, float, int]]): your inference parameters.
-
-    Returns:
-    --------
-      List of OutputDataHandler
-    """
-    raise NotImplementedError
-
-
-class TextInputModel(AnyAnyModel):
-
-  def load_model(self):
-    """
-    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.
-    """
-    raise NotImplementedError
-
-  def parse_input_request(
-      self, input_request: service_pb2.PostModelOutputsRequest) -> Tuple[List[Dict], Dict]:
-    list_input_text = [InputDataHandler.from_proto(input).text for input in input_request.inputs]
-    inference_params = json_format.MessageToDict(
-        input_request.model.model_version.output_info.params)
-
-    return list_input_text, inference_params
-
-  def predict(self, input_data: List[str],
-              inference_parameters: Dict[str, Any] = {}) -> List[OutputDataHandler]:
-    """
-    Prediction method.
-
-    Args:
-    -----
-    - input_data(List[str]): is list of text as str type
-    - inference_parameters (Dict[str, Union[bool, str, float, int]]): your inference parameters.
-
-    Returns:
-    --------
-      List of OutputDataHandler
-    """
-    raise NotImplementedError
-
-  def generate(self, input_data: List[str],
-               inference_parameters: Dict[str, Any] = {}) -> Iterator[List[OutputDataHandler]]:
-    """
-    Prediction method.
-
-    Args:
-    -----
-    - input_data(List[str]): is list of text as str type
-    - inference_parameters (Dict[str, Union[bool, str, float, int]]): your inference parameters.
-
-    Yield:
-    --------
-      List of OutputDataHandler
-    """
-    raise NotImplementedError
-
-  def stream(self, inputs: Iterator[List[str]],
-             inference_params: Dict[str, Any]) -> Iterator[List[OutputDataHandler]]:
-    """
-    Stream method.
-
-    Args:
-    -----
-    input_request: is an Iterator of Tuple which
-    - First element (List[str]) is list of input text:
-    - Second element (Dict[str, Union[bool, str, float, int]]): is a dict of inference_parameters
-
-    Yield:
-    --------
-      List of OutputDataHandler
-    """
-    raise NotImplementedError