clarifai 10.8.2__tar.gz → 10.8.4__tar.gz

{clarifai-10.8.2/clarifai.egg-info → clarifai-10.8.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: clarifai
-Version: 10.8.2
+Version: 10.8.4
 Summary: Clarifai Python SDK
 Home-page: https://github.com/Clarifai/clarifai-python
 Author: Clarifai
@@ -20,7 +20,8 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: clarifai-grpc>=10.8.6
+Requires-Dist: clarifai-grpc>=10.8.7
+Requires-Dist: clarifai-protocol>=0.0.4
 Requires-Dist: numpy>=1.22.0
 Requires-Dist: tqdm>=4.65.0
 Requires-Dist: tritonclient>=2.34.0

clarifai-10.8.4/clarifai/__init__.py

@@ -0,0 +1 @@
+__version__ = "10.8.4"

{clarifai-10.8.2 → clarifai-10.8.4}/clarifai/client/app.py

@@ -686,7 +686,7 @@ class App(Lister, BaseClient):
 
     return Workflow.from_auth_helper(auth=self.auth_helper, **kwargs)
 
-  def module(self, module_id: str, module_version_id: str = "", **kwargs) -> Module:
+  def module(self, module_id: str, **kwargs) -> Module:
     """Returns a Module object for the existing module ID.
 
     Args:
@@ -699,10 +699,9 @@ class App(Lister, BaseClient):
     Example:
         >>> from clarifai.client.app import App
         >>> app = App(app_id="app_id", user_id="user_id")
-        >>> module = app.module(module_id="module_id", module_version_id="module_version_id")
+        >>> module = app.module(module_id="module_id")
     """
-    request = service_pb2.GetModuleRequest(
-        user_app_id=self.user_app_id, module_id=module_id, version_id=module_version_id)
+    request = service_pb2.GetModuleRequest(user_app_id=self.user_app_id, module_id=module_id)
     response = self._grpc_request(self.STUB.GetModule, request)
 
     if response.status.code != status_code_pb2.SUCCESS:

{clarifai-10.8.2 → clarifai-10.8.4}/clarifai/client/model.py

@@ -281,8 +281,7 @@ class Model(Lister, BaseClient):
           "Model version ID is missing. Please provide a `model_version` with a valid `id` as an argument or as a URL in the following format: '{user_id}/{app_id}/models/{your_model_id}/model_version_id/{your_version_model_id}' when initializing."
       )
 
-    if not self.model_info.model_type_id or not self.model_info.model_version.train_log:
-      self.load_info()
+    self.load_info()
     if self.model_info.model_type_id not in TRAINABLE_MODEL_TYPES:
       raise UserError(f"Model type {self.model_info.model_type_id} is not trainable")
 

{clarifai-10.8.2 → clarifai-10.8.4}/clarifai/models/model_serving/repo_build/static_files/base_test.py

@@ -5,10 +5,10 @@ from typing import Dict, Iterable, List, Union
 import numpy as np
 import yaml
 
-from ...constants import IMAGE_TENSOR_NAME, TEXT_TENSOR_NAME
-from ...model_config import (ClassifierOutput, EmbeddingOutput, ImageOutput, InferParam,
-                             InferParamManager, MasksOutput, ModelTypes, TextOutput,
-                             VisualDetector, load_user_config)
+from clarifai.models.model_serving.constants import IMAGE_TENSOR_NAME, TEXT_TENSOR_NAME
+from clarifai.models.model_serving.model_config import (
+    ClassifierOutput, EmbeddingOutput, ImageOutput, InferParam, InferParamManager, MasksOutput,
+    ModelTypes, TextOutput, VisualDetector, load_user_config)
 
 _default_texts = ["Photo of a cat", "A cat is playing around", "Hello, this is test"]
 

clarifai-10.8.4/clarifai/runners/__init__.py

@@ -0,0 +1,14 @@
+from .models.base_typed_model import AnyAnyModel, TextInputModel, VisualInputModel
+from .models.model_runner import ModelRunner
+from .models.model_upload import ModelUploader
+from .utils.data_handler import InputDataHandler, OutputDataHandler
+
+__all__ = [
+    "ModelRunner",
+    "ModelUploader",
+    "InputDataHandler",
+    "OutputDataHandler",
+    "AnyAnyModel",
+    "TextInputModel",
+    "VisualInputModel",
+]

clarifai-10.8.4/clarifai/runners/dockerfile_template/Dockerfile.cpu.template

@@ -0,0 +1,31 @@
+ARG PYTHON_VERSION=${PYTHON_VERSION}
+FROM public.ecr.aws/docker/library/python:${PYTHON_VERSION}-slim as build
+
+# Set the working directory to /app
+WORKDIR /app
+
+COPY requirements.txt .
+# Install requirements and cleanup before leaving this line.
+# Note(zeiler): this could be in a future template as {{model_python_deps}}
+RUN python -m pip install -r requirements.txt && rm -rf /root/.cache
+
+# Install Clarifai SDK
+RUN python -m pip install clarifai
+
+# These will be set by the templaing system.
+ENV CLARIFAI_PAT=${CLARIFAI_PAT}
+ENV CLARIFAI_USER_ID=${CLARIFAI_USER_ID}
+ENV CLARIFAI_RUNNER_ID=${CLARIFAI_RUNNER_ID}
+ENV CLARIFAI_NODEPOOL_ID=${CLARIFAI_NODEPOOL_ID}
+ENV CLARIFAI_COMPUTE_CLUSTER_ID=${CLARIFAI_COMPUTE_CLUSTER_ID}
+ENV CLARIFAI_API_BASE=${CLARIFAI_API_BASE}
+
+# Copy the current folder into /app/model_dir that the SDK will expect.
+COPY . /app/model_dir/${name}
+
+# Add the model directory to the python path.
+ENV PYTHONPATH "${PYTHONPATH}:/app/model_dir/${name}"
+
+# Finally run the clarifai entrypoint to start the runner loop and local dev server.
+# Note(zeiler): we may want to make this a clarifai CLI call.
+CMD ["python", "-m", "clarifai.runners.server", "--model_path", "/app/model_dir/${name}"]

clarifai-10.8.4/clarifai/runners/dockerfile_template/Dockerfile.cuda.template

@@ -0,0 +1,129 @@
+# Build a virtualenv containing necessary system libraries and Python packages
+# for users to install their own packages while also being distroless.
+# * Install python3-venv
+# * Install gcc libpython3-dev to compile C Python modules
+# * In the virtualenv: Update pip setuputils and wheel to support building new packages
+# * Export environment variables to use the virtualenv by default
+# * Create a non-root user with minimal privileges and use it
+ARG TARGET_PLATFORM=linux/amd64
+ARG CUDA_VERSION=12.4.0
+FROM --platform=$TARGET_PLATFORM nvidia/cuda:${CUDA_VERSION}-base-ubuntu22.04 AS build
+
+ARG DRIVER_VERSION=535
+ARG PYTHON_VERSION=${PYTHON_VERSION}
+
+ENV DEBIAN_FRONTEND=noninteractive
+RUN apt-get update && \
+    apt-get install --no-install-suggests --no-install-recommends --yes \
+    software-properties-common \
+    gpg-agent && \
+    add-apt-repository ppa:graphics-drivers/ppa && \
+    add-apt-repository ppa:deadsnakes/ppa && \
+    apt-get update && \
+    apt-get install --no-install-suggests --no-install-recommends --yes \
+    python${PYTHON_VERSION} \
+    python${PYTHON_VERSION}-venv \
+    python${PYTHON_VERSION}-dev \
+    gcc \
+    libpython3-dev \
+    # drivers and nvidia-smi
+    nvidia-utils-${DRIVER_VERSION} \
+    nvidia-driver-${DRIVER_VERSION} \
+    libcap2-bin && \
+    python${PYTHON_VERSION} -m venv /venv && \
+    /venv/bin/pip install --disable-pip-version-check --upgrade pip setuptools wheel && \
+    # Create a non-root user with minimal privileges and set file permissions
+    ln -sf /usr/bin/python${PYTHON_VERSION} /usr/bin/python3 && \
+    apt-get clean && rm -rf /var/lib/apt/lists/*
+
+
+# Set environment variables to use virtualenv by default
+ENV VIRTUAL_ENV=/venv
+ENV PATH="$VIRTUAL_ENV/bin:$PATH"
+
+#############################
+# User specific requirements
+#############################
+COPY requirements.txt .
+
+# Install requirements and cleanup before leaving this line.
+# Note(zeiler): this could be in a future template as {{model_python_deps}}
+RUN python -m pip install -r requirements.txt && rm -rf /root/.cache
+
+# Install Clarifai SDK
+RUN python -m pip install clarifai
+
+#############################
+# Finally copy everything we built into a distroless image for runtime.
+######################>#######
+ARG TARGET_PLATFORM=linux/amd64
+# FROM --platform=$TARGET_PLATFORM gcr.io/distroless/python3-debian12:latest
+FROM --platform=$TARGET_PLATFORM gcr.io/distroless/python3-debian12:debug
+ARG PYTHON_VERSION=${PYTHON_VERSION}
+# needed to call pip directly
+COPY --from=build /bin/sh /bin/sh
+
+# Copy driver libraries based on architecture
+# Set FOLDER_NAME based on TARGET_PLATFORM
+ENV TARGET_PLATFORM=${TARGET_PLATFORM}
+ENV FOLDER_NAME="x86_64-linux-gnu"
+# RUN if [ "${TARGET_PLATFORM}" = "linux/arm64" ]; then \
+#         export FOLDER_NAME="aarch64-linux-gnu"; \
+#     fi && \
+#     echo "FOLDER_NAME=${FOLDER_NAME}"
+
+
+# virtual env
+COPY --from=build /venv /venv
+
+# cuda
+COPY --from=build --chmod=755 /usr/local/cuda /usr/local/cuda
+
+# We have to overwrite the python3 binary that the distroless image uses
+COPY --from=build /usr/bin/python${PYTHON_VERSION} /usr/bin/python3
+# And also copy in all the lib files for it.
+COPY --from=build /usr/lib/python${PYTHON_VERSION} /usr/lib/python${PYTHON_VERSION}
+# Note that distroless comes with a fixed python version, so we may need to overwrite that specific
+# version.
+
+# for debugging
+COPY --from=build /usr/bin/nvidia-smi /usr/bin/nvidia-smi
+# Copy driver libraries based on architecture
+COPY --from=build /usr/lib/${FOLDER_NAME}/libcuda.so* /usr/lib/${FOLDER_NAME}/
+COPY --from=build /usr/lib/${FOLDER_NAME}/libnvidia-ml.so* /usr/lib/${FOLDER_NAME}/
+
+# Set environment variables for CUDA
+ENV PATH=/usr/local/cuda/bin:${PATH}
+ENV LD_LIBRARY_PATH=/usr/local/cuda/lib64:/usr/lib/${FOLDER_NAME}:$LD_LIBRARY_PATH
+ENV CUDA_HOME=/usr/local/cuda
+
+# Set environment variables to use virtualenv by default
+ENV VIRTUAL_ENV=/venv
+# ENV PATH=${VIRTUAL_ENV}/bin:${PATH}
+ENV PYTHONPATH=${PYTHONPATH}:${VIRTUAL_ENV}/lib/python${PYTHON_VERSION}/site-packages
+
+# ENTRYPOINT ["${VIRTUAL_ENV}/bin/python"]
+
+
+# These will be set by the templaing system.
+ENV CLARIFAI_PAT=${CLARIFAI_PAT}
+ENV CLARIFAI_USER_ID=${CLARIFAI_USER_ID}
+ENV CLARIFAI_RUNNER_ID=${CLARIFAI_RUNNER_ID}
+ENV CLARIFAI_NODEPOOL_ID=${CLARIFAI_NODEPOOL_ID}
+ENV CLARIFAI_COMPUTE_CLUSTER_ID=${CLARIFAI_COMPUTE_CLUSTER_ID}
+ENV CLARIFAI_API_BASE=${CLARIFAI_API_BASE}
+
+# Set the working directory to /app
+WORKDIR /app
+
+# Copy the current folder into /app/model_dir that the SDK will expect.
+# Note(zeiler): would be nice to exclude checkpoints in case they were pre-downloaded.
+COPY . /app/model_dir/${name}
+
+# Add the model directory to the python path.
+ENV PYTHONPATH=${PYTHONPATH}:/app/model_dir/${name}
+
+
+# Finally run the clarifai entrypoint to start the runner loop and local dev server.
+# Note(zeiler): we may want to make this a clarifai CLI call.
+CMD ["-m", "clarifai.runners.server", "--model_path", "/app/model_dir/${name}"]

clarifai-10.8.4/clarifai/runners/models/base_typed_model.py

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

clarifai-10.8.4/clarifai/runners/models/model_class.py

@@ -0,0 +1,41 @@
+from abc import ABC, abstractmethod
+from typing import Iterator
+
+from clarifai_grpc.grpc.api import service_pb2
+
+
+class ModelClass(ABC):
+
+  def predict_wrapper(
+      self, request: service_pb2.PostModelOutputsRequest) -> service_pb2.MultiOutputResponse:
+    """This method is used for input/output proto data conversion"""
+    return self.predict(request)
+
+  def generate_wrapper(self, request: service_pb2.PostModelOutputsRequest
+                      ) -> Iterator[service_pb2.MultiOutputResponse]:
+    """This method is used for input/output proto data conversion and yield outcome"""
+    return self.generate(request)
+
+  def stream_wrapper(self, request: service_pb2.PostModelOutputsRequest
+                    ) -> Iterator[service_pb2.MultiOutputResponse]:
+    """This method is used for input/output proto data conversion and yield outcome"""
+    return self.stream(request)
+
+  @abstractmethod
+  def load_model(self):
+    raise NotImplementedError("load_model() not implemented")
+
+  @abstractmethod
+  def predict(self,
+              request: service_pb2.PostModelOutputsRequest) -> service_pb2.MultiOutputResponse:
+    raise NotImplementedError("run_input() not implemented")
+
+  @abstractmethod
+  def generate(self, request: service_pb2.PostModelOutputsRequest
+              ) -> Iterator[service_pb2.MultiOutputResponse]:
+    raise NotImplementedError("generate() not implemented")
+
+  @abstractmethod
+  def stream(self, request_iterator: Iterator[service_pb2.PostModelOutputsRequest]
+            ) -> Iterator[service_pb2.MultiOutputResponse]:
+    raise NotImplementedError("stream() not implemented")