clarifai 11.0.4__py3-none-any.whl → 11.0.6rc1__py3-none-any.whl

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

@@ -0,0 +1,26 @@
+# User model inference script.
+
+import os
+from pathlib import Path
+from typing import Dict, Union
+from clarifai.models.model_serving.model_config import *  # noqa
+
+
+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.
+    """
+    # current directory
+    self.base_path: Path = os.path.dirname(__file__)
+
+  def predict(self,
+              input_data: list,
+              inference_parameters: Dict[str, Union[bool, str, float, int]] = {}) -> list:
+    """predict_docstring
+    """
+
+    raise NotImplementedError()

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

@@ -0,0 +1,25 @@
+# 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

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,75 @@
+# 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

@@ -0,0 +1,31 @@
+import os
+
+from clarifai.models.model_serving.constants import CLARIFAI_PAT_PATH
+from clarifai.utils.constants import CLARIFAI_PAT_ENV_VAR
+
+
+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) and not os.environ.get(CLARIFAI_PAT_ENV_VAR, ""):
+    return None
+  if os.path.exists(CLARIFAI_PAT_PATH):
+    with open(CLARIFAI_PAT_PATH, "r") as f:
+      return f.read().replace("\n", "").replace("\r", "").strip()
+  elif os.environ.get(CLARIFAI_PAT_ENV_VAR):
+    return os.environ.get(CLARIFAI_PAT_ENV_VAR)
+  else:
+    raise ValueError(
+        f"PAT not found, please run `clarifai login` to persist your PAT or set it as an environment variable under the name '{CLARIFAI_PAT_ENV_VAR}'"
+    )
+
+
+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/deepgram_live_transcribe.py

@@ -0,0 +1,98 @@
+import os
+import httpx
+from dotenv import load_dotenv
+import threading
+
+from deepgram import (
+    DeepgramClient,
+    LiveTranscriptionEvents,
+    LiveOptions,
+)
+
+load_dotenv()
+
+# URL for the realtime streaming audio you would like to transcribe
+URL = "http://stream.live.vc.bbcmedia.co.uk/bbc_world_service"
+
+os.environ["DG_API_KEY"] = "1d5666523f0f2fbaf3e2db6ae7717f6f87280b5e"
+API_KEY = os.getenv("DG_API_KEY")
+
+
+def main():
+  try:
+    # STEP 1: Create a Deepgram client using the API key
+    deepgram = DeepgramClient(API_KEY)
+
+    # STEP 2: Create a websocket connection to Deepgram
+    dg_connection = deepgram.listen.live.v("1")
+
+    # STEP 3: Define the event handlers for the connection
+    def on_message(self, result, **kwargs):
+      sentence = result.channel.alternatives[0].transcript
+      if len(sentence) == 0:
+        return
+      print(f"speaker: {sentence}")
+
+    def on_metadata(self, metadata, **kwargs):
+      print(f"\n\n{metadata}\n\n")
+
+    def on_error(self, error, **kwargs):
+      print(f"\n\n{error}\n\n")
+
+    # STEP 4: Register the event handlers
+    dg_connection.on(LiveTranscriptionEvents.Transcript, on_message)
+    dg_connection.on(LiveTranscriptionEvents.Metadata, on_metadata)
+    dg_connection.on(LiveTranscriptionEvents.Error, on_error)
+
+    # STEP 5: Configure Deepgram options for live transcription
+    options = LiveOptions(
+        model="nova-2",
+        language="en-US",
+        smart_format=True,
+    )
+
+    # STEP 6: Start the connection
+    dg_connection.start(options)
+
+    # STEP 7: Create a lock and a flag for thread synchronization
+    lock_exit = threading.Lock()
+    exit = False
+
+    # STEP 8: Define a thread that streams the audio and sends it to Deepgram
+    def myThread():
+      with httpx.stream("GET", URL) as r:
+        for data in r.iter_bytes():
+          lock_exit.acquire()
+          if exit:
+            break
+          lock_exit.release()
+
+          dg_connection.send(data)
+
+    # STEP 9: Start the thread
+    myHttp = threading.Thread(target=myThread)
+    myHttp.start()
+
+    # STEP 10: Wait for user input to stop recording
+    input("Press Enter to stop recording...\n\n")
+
+    # STEP 11: Set the exit flag to True to stop the thread
+    lock_exit.acquire()
+    exit = True
+    lock_exit.release()
+
+    # STEP 12: Wait for the thread to finish
+    myHttp.join()
+
+    # STEP 13: Close the connection to Deepgram
+    dg_connection.finish()
+
+    print("Finished")
+
+  except Exception as e:
+    print(f"Could not open socket: {e}")
+    return
+
+
+if __name__ == "__main__":
+  main()

clarifai/runners/deepgram_live_transcribe.py~

@@ -0,0 +1,98 @@
+import os
+import httpx
+from dotenv import load_dotenv
+import threading
+
+from deepgram import (
+    DeepgramClient,
+    LiveTranscriptionEvents,
+    LiveOptions,
+)
+
+load_dotenv()
+
+# URL for the realtime streaming audio you would like to transcribe
+URL = "http://stream.live.vc.bbcmedia.co.uk/bbc_world_service"
+
+os.environ.set("DG_API_KEY", "1d5666523f0f2fbaf3e2db6ae7717f6f87280b5e")
+API_KEY = os.getenv("DG_API_KEY")
+
+
+def main():
+  try:
+    # STEP 1: Create a Deepgram client using the API key
+    deepgram = DeepgramClient(API_KEY)
+
+    # STEP 2: Create a websocket connection to Deepgram
+    dg_connection = deepgram.listen.live.v("1")
+
+    # STEP 3: Define the event handlers for the connection
+    def on_message(self, result, **kwargs):
+      sentence = result.channel.alternatives[0].transcript
+      if len(sentence) == 0:
+        return
+      print(f"speaker: {sentence}")
+
+    def on_metadata(self, metadata, **kwargs):
+      print(f"\n\n{metadata}\n\n")
+
+    def on_error(self, error, **kwargs):
+      print(f"\n\n{error}\n\n")
+
+    # STEP 4: Register the event handlers
+    dg_connection.on(LiveTranscriptionEvents.Transcript, on_message)
+    dg_connection.on(LiveTranscriptionEvents.Metadata, on_metadata)
+    dg_connection.on(LiveTranscriptionEvents.Error, on_error)
+
+    # STEP 5: Configure Deepgram options for live transcription
+    options = LiveOptions(
+        model="nova-2",
+        language="en-US",
+        smart_format=True,
+    )
+
+    # STEP 6: Start the connection
+    dg_connection.start(options)
+
+    # STEP 7: Create a lock and a flag for thread synchronization
+    lock_exit = threading.Lock()
+    exit = False
+
+    # STEP 8: Define a thread that streams the audio and sends it to Deepgram
+    def myThread():
+      with httpx.stream("GET", URL) as r:
+        for data in r.iter_bytes():
+          lock_exit.acquire()
+          if exit:
+            break
+          lock_exit.release()
+
+          dg_connection.send(data)
+
+    # STEP 9: Start the thread
+    myHttp = threading.Thread(target=myThread)
+    myHttp.start()
+
+    # STEP 10: Wait for user input to stop recording
+    input("Press Enter to stop recording...\n\n")
+
+    # STEP 11: Set the exit flag to True to stop the thread
+    lock_exit.acquire()
+    exit = True
+    lock_exit.release()
+
+    # STEP 12: Wait for the thread to finish
+    myHttp.join()
+
+    # STEP 13: Close the connection to Deepgram
+    dg_connection.finish()
+
+    print("Finished")
+
+  except Exception as e:
+    print(f"Could not open socket: {e}")
+    return
+
+
+if __name__ == "__main__":
+  main()

clarifai/runners/deepgram_runner.py

@@ -0,0 +1,131 @@
+import os
+import time
+import httpx
+from dotenv import load_dotenv
+import threading
+import queue
+import hashlib
+
+from deepgram import (
+    DeepgramClient,
+    LiveTranscriptionEvents,
+    LiveOptions,
+)
+
+load_dotenv()
+
+os.environ["DG_API_KEY"] = "1d5666523f0f2fbaf3e2db6ae7717f6f87280b5e"
+API_KEY = os.getenv("DG_API_KEY")
+
+from clarifai_grpc.grpc.api import resources_pb2, service_pb2
+from collections.abc import Iterator
+from google.protobuf import json_format
+
+from clarifai.client.runner import Runner
+
+
+class MyRunner(Runner):
+  """A custom runner that adds "Hello World" to the end of the text and replaces the domain of the
+  image URL as an example.
+  """
+
+  def setup_connection(self):
+    print("ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZz")
+    # STEP 2: Create a websocket connection to Deepgram
+    self.dg_connection = self.deepgram.listen.live.v("1")
+
+    output_q = self.output_q
+
+    # STEP 3: Define the event handlers for the connection
+    def on_message(self, result, **kwargs):
+      if result.is_final:
+        sentence = result.channel.alternatives[0].transcript
+        if len(sentence) == 0:
+          return
+        print("SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS")
+        print(f"speaker: {sentence}")
+        # put it on a queue as we get responses from deepgram.
+        output_q.put(sentence)
+
+    def on_metadata(self, metadata, **kwargs):
+      print(f"\n\n{metadata}\n\n")
+
+    def on_error(self, error, **kwargs):
+      print(f"\n\n{error}\n\n")
+
+    # STEP 4: Register the event handlers
+    self.dg_connection.on(LiveTranscriptionEvents.Transcript, on_message)
+    self.dg_connection.on(LiveTranscriptionEvents.Metadata, on_metadata)
+    self.dg_connection.on(LiveTranscriptionEvents.Error, on_error)
+
+    # STEP 5: Configure Deepgram options for live transcription
+    self.options = LiveOptions(
+        model="nova-2",
+        language="en-US",
+        smart_format=True,
+    )
+
+    # STEP 6: Start the connection
+    self.dg_connection.start(self.options)
+
+    print("DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD")
+    print(self.dg_connection._socket)
+
+  def __init__(self, *args, **kwargs):
+    print("MyRunner init")
+    # STEP 1: Create a Deepgram client using the API key
+    self.deepgram = DeepgramClient(API_KEY)
+    self.output_q = queue.Queue()
+
+    self.setup_connection()
+
+    super().__init__(*args, **kwargs)
+
+  def stream(self, request: service_pb2.PostModelOutputsRequest
+            ) -> Iterator[service_pb2.MultiOutputResponse]:
+    """Example yielding a whole batch of streamed stuff back.
+    """
+
+    assert len(request.inputs) == 1, "This runner only supports one input at a time."
+
+    # Get the next chunk of data from the incoming stream.
+
+    print("Got some audio data")
+
+    data = request.inputs[0].data.audio.base64
+    print(hashlib.md5(data).hexdigest())
+
+    # FIXME(zeiler): this doesnt' work but isn't iportant to our system.
+    if not self.dg_connection._socket:
+      #self.dg_connection.finish()
+      #self.dg_connection.start(self.options)
+      self.setup_connection()
+    self.dg_connection.send(data)
+    print("Sent it to deepgram")
+
+    while True:
+      try:
+        item = self.output_q.get(timeout=0.1)
+        output = resources_pb2.Output()
+        output.data.text.raw = item
+        output.status.code = 10000
+        print("YYYYYYYYYYYYYYYYYYYYYYYYYYYYYY")
+        print("Yielding: ", output.data.text.raw)
+        yield service_pb2.MultiOutputResponse(outputs=[
+            output,
+        ])
+      except queue.Empty:
+        print("Queue is empty, sleeping then breaking")
+        break
+
+  # # STEP 13: Close the connection to Deepgram
+  # dg_connection.finish()
+
+
+if __name__ == '__main__':
+  # Make sure you set these env vars before running the example.
+  # CLARIFAI_PAT
+  # CLARIFAI_USER_ID
+
+  # You need to first create a runner in the Clarifai API and then use the ID here.
+  MyRunner(runner_id="matt-test-runner", base_url="http://q6:32013", num_parallel_polls=1).start()

clarifai/runners/deepgram_runner.py~

@@ -0,0 +1,130 @@
+import os
+import time
+import httpx
+from dotenv import load_dotenv
+import threading
+import queue
+import hashlib
+
+from deepgram import (
+    DeepgramClient,
+    LiveTranscriptionEvents,
+    LiveOptions,
+)
+
+load_dotenv()
+
+os.environ["DG_API_KEY"] = "1d5666523f0f2fbaf3e2db6ae7717f6f87280b5e"
+API_KEY = os.getenv("DG_API_KEY")
+
+from clarifai_grpc.grpc.api import resources_pb2, service_pb2
+from collections.abc import Iterator
+from google.protobuf import json_format
+
+from clarifai.client.runner import Runner
+
+
+class MyRunner(Runner):
+  """A custom runner that adds "Hello World" to the end of the text and replaces the domain of the
+  image URL as an example.
+  """
+
+  def setup_connection(self):
+    print("ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZz")
+    # STEP 2: Create a websocket connection to Deepgram
+    self.dg_connection = self.deepgram.listen.live.v("1")
+
+    output_q = self.output_q
+
+    # STEP 3: Define the event handlers for the connection
+    def on_message(self, result, **kwargs):
+      if result.is_final:
+        sentence = result.channel.alternatives[0].transcript
+        if len(sentence) == 0:
+          return
+        print("SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS")
+        print(f"speaker: {sentence}")
+        # put it on a queue as we get responses from deepgram.
+        output_q.put(sentence)
+
+    def on_metadata(self, metadata, **kwargs):
+      print(f"\n\n{metadata}\n\n")
+
+    def on_error(self, error, **kwargs):
+      print(f"\n\n{error}\n\n")
+
+    # STEP 4: Register the event handlers
+    self.dg_connection.on(LiveTranscriptionEvents.Transcript, on_message)
+    self.dg_connection.on(LiveTranscriptionEvents.Metadata, on_metadata)
+    self.dg_connection.on(LiveTranscriptionEvents.Error, on_error)
+
+    # STEP 5: Configure Deepgram options for live transcription
+    self.options = LiveOptions(
+        model="nova-2",
+        language="en-US",
+        smart_format=True,
+    )
+
+    # STEP 6: Start the connection
+    self.dg_connection.start(self.options)
+
+    print("DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD")
+    print(self.dg_connection._socket)
+
+  def __init__(self, *args, **kwargs):
+    print("MyRunner init")
+    # STEP 1: Create a Deepgram client using the API key
+    self.deepgram = DeepgramClient(API_KEY)
+    self.output_q = queue.Queue()
+
+    self.setup_connection()
+
+    super().__init__(*args, **kwargs)
+
+  def stream(self, request: service_pb2.PostModelOutputsRequest
+            ) -> Iterator[service_pb2.MultiOutputResponse]:
+    """Example yielding a whole batch of streamed stuff back.
+    """
+
+    assert len(request.inputs) == 1, "This runner only supports one input at a time."
+
+    # Get the next chunk of data from the incoming stream.
+
+    print("Got some audio data")
+
+    data = request.inputs[0].data.audio.base64
+    print(hashlib.md5(data).hexdigest())
+
+    if not self.dg_connection._socket:
+      self.dg_connection.finish()
+      self.dg_connection.start(self.options)
+      #self.setup_connection()
+    self.dg_connection.send(data)
+    print("Sent it to deepgram")
+
+    while True:
+      try:
+        item = self.output_q.get(timeout=0.1)
+        output = resources_pb2.Output()
+        output.data.text.raw = item
+        output.status.code = 10000
+        print("YYYYYYYYYYYYYYYYYYYYYYYYYYYYYY")
+        print("Yielding: ", output.data.text.raw)
+        yield service_pb2.MultiOutputResponse(outputs=[
+            output,
+        ])
+      except queue.Empty:
+        print("Queue is empty, sleeping then breaking")
+        break
+
+  # # STEP 13: Close the connection to Deepgram
+  # dg_connection.finish()
+
+
+if __name__ == '__main__':
+  # Make sure you set these env vars before running the example.
+  # CLARIFAI_PAT
+  # CLARIFAI_USER_ID
+
+  # You need to first create a runner in the Clarifai API and then use the ID here.
+  MyRunner(runner_id="matt-test-runner", base_url="http://q6:32013", num_parallel_polls=1).start()