clarifai 9.11.1__py3-none-any.whl → 10.0.0__py3-none-any.whl

clarifai/client/input.py

@@ -7,11 +7,13 @@ from concurrent.futures import ThreadPoolExecutor, as_completed
 from multiprocessing import cpu_count
 from typing import Generator, List, Union
 
+import requests
 from clarifai_grpc.grpc.api import resources_pb2, service_pb2  # noqa: F401
 from clarifai_grpc.grpc.api.resources_pb2 import Annotation, Audio, Image, Input, Text, Video
 from clarifai_grpc.grpc.api.status import status_code_pb2, status_pb2
 from google.protobuf.json_format import MessageToDict
 from google.protobuf.struct_pb2 import Struct
+from requests.adapters import HTTPAdapter, Retry
 from tqdm import tqdm
 
 from clarifai.client.base import BaseClient
@@ -306,7 +308,7 @@ class Inputs(Lister, BaseClient):
         >>> from clarifai.client.input import Inputs
         >>> input_protos = Inputs.get_multimodal_input(input_id = 'demo', raw_text = 'What time of day is it?', image_url='https://samples.clarifai.com/metro-north.jpg')
     """
-    if (image_bytes and image_url) or (not image_url and not image_url):
+    if (image_bytes and image_url) or (not image_bytes and not image_url):
       return UserError("Please supply only one of image_bytes or image_url, and not both.")
     if (text_bytes and raw_text) or (not text_bytes and not raw_text):
       return UserError("Please supply only one of text_bytes or raw_text, and not both.")
@@ -729,6 +731,37 @@ class Inputs(Lister, BaseClient):
       raise Exception(response.status)
     self.logger.info("\nInputs Deleted\n%s", response.status)
 
+  def download_inputs(self, inputs: List[Input]) -> List[bytes]:
+    """Download list of input objects from the app.
+
+    Args:
+        input_ids (Input): List of input objects to download.
+
+    Example:
+        >>> from clarifai.client.user import User
+        >>> input_obj = User(user_id="user_id").app(app_id="app_id").inputs()
+        >>> input_obj.download_inputs(list(input_obj.list_inputs()))
+    """
+    if not isinstance(inputs, list):
+      raise UserError("input_ids must be a list of input ids")
+    final_inputs = []
+    #initiate session
+    session = requests.Session()
+    retries = Retry(total=3, backoff_factor=0.1, status_forcelist=[500, 502, 503, 504])
+    session.mount('https://', HTTPAdapter(max_retries=retries))
+    session.headers.update({'Authorization': self.metadata[0][1]})
+    # download inputs
+    data_types = ['image', 'video', 'audio', 'text']
+    for input in inputs:
+      for data_type in data_types:
+        url = getattr(input.data, data_type).url
+        if url:
+          response = session.get(url, stream=True)
+          if response.status_code == 200:
+            final_inputs.append(response.content)
+
+    return final_inputs
+
   def list_inputs(self,
                   dataset_id: str = None,
                   page_no: int = None,

clarifai/client/workflow.py

@@ -58,11 +58,12 @@ class Workflow(Lister, BaseClient):
     BaseClient.__init__(self, user_id=self.user_id, app_id=self.app_id, base=base_url, pat=pat)
     Lister.__init__(self)
 
-  def predict(self, inputs: List[Input]):
+  def predict(self, inputs: List[Input], workflow_state_id: str = None):
     """Predicts the workflow based on the given inputs.
 
     Args:
         inputs (list[Input]): The inputs to predict.
+        workflow_state_id (str): key for the workflow state cache that stores the workflow node predictions.
     """
     if len(inputs) > MAX_WORKFLOW_PREDICT_INPUTS:
       raise UserError(f"Too many inputs. Max is {MAX_WORKFLOW_PREDICT_INPUTS}."
@@ -74,6 +75,9 @@ class Workflow(Lister, BaseClient):
         inputs=inputs,
         output_config=self.output_config)
 
+    if workflow_state_id:
+      request.workflow_state.id = workflow_state_id
+
     start_time = time.time()
     backoff_iterator = BackoffIterator()
 
@@ -81,7 +85,7 @@ class Workflow(Lister, BaseClient):
       response = self._grpc_request(self.STUB.PostWorkflowResults, request)
 
       if response.status.code == status_code_pb2.MODEL_DEPLOYING and \
-          time.time() - start_time < 60:
+          time.time() - start_time < 60*10:  # 10 minutes
         self.logger.info(f"{self.id} Workflow is still deploying, please wait...")
         time.sleep(next(backoff_iterator))
         continue

clarifai/constants/rag.py

@@ -0,0 +1 @@
+MAX_UPLOAD_BATCH_SIZE = 128

clarifai/models/model_serving/README.md

@@ -151,7 +151,7 @@ Additional methods can be added to this script's `Infer` class by the user as de
 - [Model types docs](docs/model_types.md)
 - [Model Output types docs](docs/output.md)
 - [Dependencies](docs/dependencies.md)
-- [Examples](examples/)
+- [Examples](https://github.com/Clarifai/examples)
 - [Custom Configs](docs/custom_config.md/)
 
 ## Prerequisites

clarifai/models/model_serving/models/default_test.py

@@ -67,6 +67,9 @@ class DefaultTestInferenceModel(unittest.TestCase):
                   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

clarifai/rag/__init__.py

@@ -0,0 +1,3 @@
+from .rag import RAG
+
+__all__ = ["RAG"]

clarifai/rag/rag.py

@@ -0,0 +1,261 @@
+import uuid
+from datetime import datetime
+from typing import List
+
+import yaml
+from clarifai_grpc.grpc.api import resources_pb2  # noqa: F401
+from google.protobuf.struct_pb2 import Struct
+
+from clarifai.client.app import App
+from clarifai.client.input import Inputs
+from clarifai.client.model import Model
+from clarifai.client.user import User
+from clarifai.client.workflow import Workflow
+from clarifai.constants.rag import MAX_UPLOAD_BATCH_SIZE
+from clarifai.errors import UserError
+from clarifai.rag.utils import (convert_messages_to_str, format_assistant_message, load_documents,
+                                split_document)
+from clarifai.utils.logging import get_logger
+
+
+class RAG:
+  """
+    RAG is a class for Retrieval Augmented Generation.
+
+    Example:
+        >>> from clarifai.rag import RAG
+        >>> rag_agent = RAG()
+    """
+  chat_state_id = None
+
+  def __init__(self,
+               workflow_url: str = None,
+               workflow: Workflow = None,
+               base_url: str = "https://api.clarifai.com",
+               pat: str = None,
+               **kwargs):
+    """Initialize an empty or existing RAG.
+    """
+    self.logger = get_logger(logger_level="INFO", name=__name__)
+    if workflow_url is not None and workflow is None:
+      self.logger.info("workflow_url:%s", workflow_url)
+      w = Workflow(workflow_url, base_url=base_url, pat=pat)
+      self._prompt_workflow = w
+      self._app = App(app_id=w.app_id, base_url=w.base, pat=w.pat)
+    elif workflow_url is None and workflow is not None:
+      self._prompt_workflow = workflow
+      self._app = App(app_id=workflow.app_id, base_url=workflow.base, pat=workflow.pat)
+
+  @classmethod
+  def setup(cls,
+            user_id: str = None,
+            llm_url: str = "https://clarifai.com/mistralai/completion/models/mistral-7B-Instruct",
+            base_workflow: str = "Text",
+            workflow_yaml_filename: str = 'prompter_wf.yaml',
+            base_url: str = "https://api.clarifai.com",
+            pat: str = None,
+            **kwargs):
+    """Creates an app with `Text` as base workflow, create prompt model, create prompt workflow.
+
+    Example:
+        >>> from clarifai.rag import RAG
+        >>> rag_agent = RAG.setup()
+    """
+    user = User(user_id=user_id, base_url=base_url, pat=pat)
+    llm = Model(llm_url)
+
+    params = Struct()
+    params.update({
+        "prompt_template":
+            "Context information is below:\n{data.hits}\nGiven the context information and not prior knowledge, answer the query.\nQuery: {data.text.raw}\nAnswer: "
+    })
+    prompter_model_params = {"params": params}
+
+    ## Create an App
+    now_ts = str(int(datetime.now().timestamp()))
+    app_id = f"rag_app_{now_ts}"
+    app = user.create_app(app_id=app_id, base_workflow=base_workflow)
+
+    ## Create rag-prompter model and version
+    prompter_model = app.create_model(
+        model_id=f"rag_prompter_{now_ts}", model_type_id="rag-prompter")
+    prompter_model = prompter_model.create_version(output_info=prompter_model_params)
+
+    ## Generate a tmp yaml file for workflow creation
+    workflow_id = f"rag-wf-{now_ts}"
+    workflow_dict = {
+        "workflow": {
+            "id":
+                workflow_id,
+            "nodes": [{
+                "id": "rag-prompter",
+                "model": {
+                    "model_id": prompter_model.id,
+                    "model_version_id": prompter_model.model_version.id
+                }
+            }, {
+                "id": "llm",
+                "model": {
+                    "model_id": llm.id,
+                    "user_id": llm.user_id,
+                    "app_id": llm.app_id
+                },
+                "node_inputs": [{
+                    "node_id": "rag-prompter"
+                }]
+            }]
+        }
+    }
+    with open(workflow_yaml_filename, 'w') as out_file:
+      yaml.dump(workflow_dict, out_file, default_flow_style=False)
+
+    ## Create prompt workflow
+    wf = app.create_workflow(config_filepath=workflow_yaml_filename)
+    del user, llm, prompter_model, prompter_model_params
+    return cls(workflow=wf)
+
+  def upload(self,
+             file_path: str = None,
+             folder_path: str = None,
+             url: str = None,
+             batch_size: int = 128,
+             chunk_size: int = 1024,
+             chunk_overlap: int = 200,
+             **kwargs) -> None:
+    """Uploads documents to the app.
+        - Read from a local directory or public url or local filename.
+        - Parse the document(s) into chunks.
+        - Ingest chunks into the app with metadata.
+
+    Args:
+        file_path str: File path to the document.
+        folder_path str: Folder path to the documents.
+        url str: Public url to the document.
+        batch_size int: Batch size for uploading.
+        chunk_size int: Chunk size for splitting the document.
+        chunk_overlap int: The token overlap of each chunk when splitting.
+        **kwargs: Additional arguments for the SentenceSplitter. Refer https://docs.llamaindex.ai/en/stable/api/llama_index.node_parser.SentenceSplitter.html
+
+    Example:
+        >>> from clarifai.rag import RAG
+        >>> rag_agent = RAG.setup()
+        >>> rag_agent.upload(folder_path = "~/work/docs")
+        >>> rag_agent.upload(file_path = "~/work/docs/manual.pdf")
+    """
+    #set batch size
+    if batch_size > MAX_UPLOAD_BATCH_SIZE:
+      raise ValueError(f"batch_size cannot be greater than {MAX_UPLOAD_BATCH_SIZE}")
+
+    #check if only one of file_path, folder_path, or url is specified
+    if file_path and (folder_path or url):
+      raise ValueError("Only one of file_path, folder_path, or url can be specified.")
+    if folder_path and (file_path or url):
+      raise ValueError("Only one of file_path, folder_path, or url can be specified.")
+    if url and (file_path or folder_path):
+      raise ValueError("Only one of file_path, folder_path, or url can be specified.")
+
+    #loading documents
+    documents = load_documents(file_path=file_path, folder_path=folder_path, url=url)
+
+    #splitting documents into chunks
+    text_chunks = []
+    metadata = []
+
+    #iterate through documents
+    for doc in documents:
+      cur_text_chunks = split_document(
+          text=doc.text, chunk_size=chunk_size, chunk_overlap=chunk_overlap, **kwargs)
+      text_chunks.extend(cur_text_chunks)
+      metadata.extend([doc.metadata for _ in range(len(cur_text_chunks))])
+      #if batch size is reached, upload the batch
+      if len(text_chunks) > batch_size:
+        for idx in range(0, len(text_chunks), batch_size):
+          if idx + batch_size > len(text_chunks):
+            continue
+          batch_texts = text_chunks[0:batch_size]
+          batch_ids = [uuid.uuid4().hex for _ in range(batch_size)]
+          #metadata
+          batch_metadatas = metadata[0:batch_size]
+          meta_list = []
+          for meta in batch_metadatas:
+            meta_struct = Struct()
+            meta_struct.update(meta)
+            meta_list.append(meta_struct)
+          del batch_metadatas
+          #creating input proto
+          input_batch = [
+              self._app.inputs().get_text_input(
+                  input_id=batch_ids[i],
+                  raw_text=text,
+                  metadata=meta_list[i],
+              ) for i, text in enumerate(batch_texts)
+          ]
+          #uploading input with metadata
+          self._app.inputs().upload_inputs(inputs=input_batch)
+          #delete uploaded chunks
+          del text_chunks[0:batch_size]
+          del metadata[0:batch_size]
+
+    #uploading the remaining chunks
+    if len(text_chunks) > 0:
+      batch_size = len(text_chunks)
+      batch_ids = [uuid.uuid4().hex for _ in range(batch_size)]
+      #metadata
+      batch_metadatas = metadata[0:batch_size]
+      meta_list = []
+      for meta in batch_metadatas:
+        meta_struct = Struct()
+        meta_struct.update(meta)
+        meta_list.append(meta_struct)
+      del batch_metadatas
+      #creating input proto
+      input_batch = [
+          self._app.inputs().get_text_input(
+              input_id=batch_ids[i],
+              raw_text=text,
+              metadata=meta_list[i],
+          ) for i, text in enumerate(text_chunks)
+      ]
+      #uploading input with metadata
+      self._app.inputs().upload_inputs(inputs=input_batch)
+      del text_chunks
+      del metadata
+
+  def chat(self, messages: List[dict], client_manage_state: bool = False) -> List[dict]:
+    """Chat interface in OpenAI API format.
+
+    Args:
+        messages List[dict]: A list of dictionary in the following format:
+        ```
+        [
+          {"role": "user", "content": "Hello there."},
+          {"role": "assistant", "content": "Hi, I'm Claude. How can I help you?"},
+          {"role": "user", "content": "Can you explain LLMs in plain English?"},
+        ]
+        ```
+        client_manage_state (bool): Whether the client will handle chat state management. Default is false.
+
+    This will pass back the workflow state ID for the server to store chat state.
+    """
+    if client_manage_state:
+      single_prompt = convert_messages_to_str(messages)
+      input_proto = Inputs._get_proto("", "", text_pb=resources_pb2.Text(raw=single_prompt))
+      response = self._prompt_workflow.predict([input_proto])
+      messages.append(format_assistant_message(response.results[0].outputs[-1].data.text.raw))
+      return messages
+
+    # server-side state management
+    message = messages[-1].get("content", "")
+    if len(message) == 0:
+      raise UserError("Empty message supplied.")
+
+    # get chat state id
+    chat_state_id = "init" if self.chat_state_id is None else self.chat_state_id
+
+    # call predict
+    input_proto = Inputs._get_proto("", "", text_pb=resources_pb2.Text(raw=message))
+    response = self._prompt_workflow.predict([input_proto], workflow_state_id=chat_state_id)
+
+    # store chat state id
+    self.chat_state_id = response.workflow_state.id
+    return [format_assistant_message(response.results[0].outputs[-1].data.text.raw)]

clarifai/rag/utils.py

@@ -0,0 +1,102 @@
+import io
+from pathlib import Path
+from typing import List
+
+import requests
+from llama_index import Document, SimpleDirectoryReader, download_loader
+from llama_index.node_parser.text import SentenceSplitter
+from pypdf import PdfReader
+
+
+## TODO: Make this token-aware.
+def convert_messages_to_str(messages: List[dict]) -> str:
+  """convert messages in OpenAI API format into a single string.
+
+    Args:
+        messages List[dict]: A list of dictionary in the following format:
+        ```
+        [
+          {"role": "user", "content": "Hello there."},
+          {"role": "assistant", "content": "Hi, I'm Claude. How can I help you?"},
+          {"role": "user", "content": "Can you explain LLMs in plain English?"},
+        ]
+        ```
+    """
+  final_str = ""
+  for msg in messages:
+    if "role" in msg and "content" in msg:
+      role = msg.get("role", "")
+      content = msg.get("content", "")
+      final_str += f"\n\n{role}: {content}"
+  return final_str
+
+
+def format_assistant_message(raw_text: str) -> dict:
+  return {"role": "assistant", "content": raw_text}
+
+
+def load_documents(file_path: str = None, folder_path: str = None,
+                   url: str = None) -> List[Document]:
+  """Loads documents from a local directory or public url or local filename.
+
+  Args:
+      file_path (str): The path to the filename.
+      folder_path (str): The path to the folder.
+      url (str): The url to the file.
+  """
+  #document loaders for filepath
+  if file_path:
+    if file_path.endswith(".pdf"):
+      PDFReader = download_loader("PDFReader")
+      loader = PDFReader()
+      documents = loader.load_data(file=Path(file_path))
+    elif file_path.endswith(".docx"):
+      docReader = download_loader("DocxReader")
+      loader = docReader()
+      documents = loader.load_data(file=Path(file_path))
+    elif file_path.endswith(".txt"):
+      with open(file_path, 'r') as file:
+        text_content = file.read()
+      documents = [Document(text=text_content)]
+    else:
+      raise ValueError("Only .pdf, .docx, and .txt files are supported.")
+
+  #document loaders for folderpath
+  if folder_path:
+    documents = SimpleDirectoryReader(
+        input_dir=Path(folder_path), required_exts=[".pdf", ".docx"]).load_data()
+
+  #document loaders for url
+  if url:
+    response = requests.get(url)
+    if response.status_code != 200:
+      raise ValueError(f"Invalid url {url}.")
+    #for text files
+    try:
+      documents = [Document(text=response.content)]
+    #for pdf files
+    except Exception:
+      documents = []
+      pdf_file = PdfReader(io.BytesIO(response.content))
+      num_pages = len(pdf_file.pages)
+      for page in range(num_pages):
+        page_text = pdf_file.pages[page].extract_text()
+        documents.append(Document(text=page_text))
+    else:
+      raise ValueError(f"Invalid url {url}.")
+
+  return documents
+
+
+def split_document(text: str, chunk_size: int, chunk_overlap: int, **kwargs) -> List[str]:
+  """Splits a document into chunks of text.
+
+  Args:
+      text (str): The text to split.
+      chunk_size (int): The size of each chunk.
+      chunk_overlap (int): The amount of overlap between each chunk.
+      **kwargs: Additional keyword arguments for the SentenceSplitter.
+  """
+  text_parser = SentenceSplitter(chunk_size=chunk_size, chunk_overlap=chunk_overlap, **kwargs)
+  text_chunks = text_parser.split_text(text)
+  return text_chunks

clarifai/versions.py

@@ -1,6 +1,6 @@
 import os
 
-CLIENT_VERSION = "9.11.1"
+CLIENT_VERSION = "10.0.0"
 OS_VER = os.sys.platform
 PYTHON_VERSION = '.'.join(
     map(str, [os.sys.version_info.major, os.sys.version_info.minor, os.sys.version_info.micro]))

{clarifai-9.11.1.dist-info → clarifai-10.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: clarifai
-Version: 9.11.1
+Version: 10.0.0
 Summary: Clarifai Python SDK
 Home-page: https://github.com/Clarifai/clarifai-python
 Author: Clarifai
@@ -20,7 +20,7 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: clarifai-grpc (~=9.11.5)
+Requires-Dist: clarifai-grpc (~=10.0.1)
 Requires-Dist: pandas (>=1.3.5)
 Requires-Dist: numpy (>=1.22.0)
 Requires-Dist: tqdm (>=4.65.0)
@@ -30,6 +30,8 @@ Requires-Dist: rich (>=13.4.2)
 Requires-Dist: PyYAML (>=6.0.1)
 Requires-Dist: schema (>=0.7.5)
 Requires-Dist: Pillow (>=9.5.0)
+Requires-Dist: llama-index (>=0.9.27)
+Requires-Dist: pypdf (>=3.17.4)
 Provides-Extra: all
 Requires-Dist: pycocotools (==2.0.6) ; extra == 'all'
 
@@ -55,7 +57,7 @@ Clarifai Python SDK</a>
 
 This is the official Python client for interacting with our powerful [API](https://docs.clarifai.com). The Clarifai Python SDK offers a comprehensive set of tools to integrate Clarifai's AI platform to leverage computer vision capabilities like classification , detection ,segementation and natural language capabilities like classification , summarisation , generation , Q&A ,etc into your applications. With just a few lines of code, you can leverage cutting-edge artificial intelligence to unlock valuable insights from visual and textual content.
 
-[Website](https://www.clarifai.com/) | [Demo](https://clarifai.com/demo) | [Signup for a Free Account](https://clarifai.com/signup) | [API Docs](https://docs.clarifai.com/) | [Clarifai Community](https://clarifai.com/explore) | [Python SDK Docs](https://docs.clarifai.com/python-sdk/api-reference) | [Examples](https://github.com/Clarifai/examples) | [Colab Notebooks](https://github.com/Clarifai/colab-notebooks) | [Discord](https://discord.gg/XAPE3Vtg)
+[Website](https://www.clarifai.com/) | [Schedule Demo](https://www.clarifai.com/company/schedule-demo) | [Signup for a Free Account](https://clarifai.com/signup) | [API Docs](https://docs.clarifai.com/) | [Clarifai Community](https://clarifai.com/explore) | [Python SDK Docs](https://docs.clarifai.com/python-sdk/api-reference) | [Examples](https://github.com/Clarifai/examples) | [Colab Notebooks](https://github.com/Clarifai/colab-notebooks) | [Discord](https://discord.gg/XAPE3Vtg)
 
 
 ---
@@ -212,6 +214,17 @@ annotations_list = list(annotation_generator)
 all_concepts = list(app.list_concepts())
 ```
 
+#### Input Download
+```python
+#listing inputs
+input_generator = input_obj.list_inputs(page_no=1,per_page=1,input_type='image')
+inputs_list = list(input_generator)
+
+#downloading_inputs
+input_bytes = input_obj.download_inputs(inputs_list)
+with open('demo.jpg','wb') as f:
+  f.write(input_bytes[0])
+```
 
 
 ## :brain: Interacting with Models

clarifai-10.0.0.dist-info/RECORD

@@ -0,0 +1,103 @@
+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=Cn5tG5KdKzm7wU4_DT4tDhqLJK6sJXSLOOcobru_Qbw,186
+clarifai/client/__init__.py,sha256=xI1U0l5AZdRThvQAXCLsd9axxyFzXXJ22m8LHqVjQRU,662
+clarifai/client/app.py,sha256=AWUngtwF6a0uS9DInf2arz5Aa-vbxt2Ce5WSNvwlAo0,26946
+clarifai/client/base.py,sha256=_GBkBBOAM-_3ATEoTb9LzKpktMYww9VL0Z4IhUExGfY,4753
+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=CLzFvSlmyJVskaeAoO-zwe7TtY9qf0ssjAlviFjiMng,9985
+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.0.dist-info/LICENSE,sha256=mUqF_d12-qE2n41g7C5_sq-BMLOcj6CNN-jevr15YHU,555
+clarifai-10.0.0.dist-info/METADATA,sha256=_D7x85LAiktmEtHcPaETPmMOmM2XLqBbQKClc0302M8,16510
+clarifai-10.0.0.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+clarifai-10.0.0.dist-info/entry_points.txt,sha256=cna1vVlFIZZZlxHy1AbhooFGy-dw1W2xRfbOVRSWSKg,255
+clarifai-10.0.0.dist-info/top_level.txt,sha256=wUMdCQGjkxaynZ6nZ9FAnvBUCgp5RJUVFSy2j-KYo0s,9
+clarifai-10.0.0.dist-info/RECORD,,

clarifai/models/model_serving/examples/README.md

@@ -1,7 +0,0 @@
-## Clarifai Model Upload Examples
-
-A collection of pre-built triton models for different tasks.
-To run inference locally using any of the examples here, you need to have the [Triton Inference Server](https://github.com/triton-inference-server/server/blob/main/docs/customization_guide/build.md#building-with-docker) installed.
-
-Additionally some models may require other files such as checkpoints be downloaded before testing and/or deployment to Clarifai as they are ommitted here due to github file size limits.
-See the Readme files under each model to see if there any additional files required and where to place them.