apolo-app-types 25.4.3__py3-none-any.whl

apolo_app_types/__init__.py

@@ -0,0 +1,159 @@
+from apolo_app_types.protocols.apolo_deploy import ApoloDeployInputs, ApoloDeployOutputs
+from apolo_app_types.protocols.common import (
+    ApoloFilesMount,
+    ApoloSecret,
+    AppInputs,
+    AppInputsDeployer,
+    AppOutputs,
+    AppOutputsDeployer,
+    BasicAuth,
+    Bucket,
+    Env,
+    HuggingFaceModel,
+    OptionalStrOrSecret,
+    StrOrSecret,
+)
+from apolo_app_types.protocols.custom_deployment import (
+    Container,
+    ContainerImage,
+    CustomDeploymentInputs,
+    CustomDeploymentOutputs,
+    Service,
+)
+from apolo_app_types.protocols.dify import (
+    DifyApi,
+    DifyInputs,
+    DifyOutputs,
+    DifyProxy,
+    DifyWeb,
+    DifyWorker,
+)
+from apolo_app_types.protocols.dockerhub import (
+    DockerConfigModel,
+    DockerHubInputs,
+    DockerHubOutputs,
+)
+from apolo_app_types.protocols.fooocus import (
+    FooocusAppInputs,
+    FooocusInputs,
+    FooocusOutputs,
+)
+from apolo_app_types.protocols.huggingface_cache import (
+    HuggingFaceCacheInputs,
+    HuggingFaceCacheOutputs,
+)
+from apolo_app_types.protocols.jupyter import (
+    JupyterInputs,
+    JupyterOutputs,
+    JupyterTypes,
+)
+from apolo_app_types.protocols.llm import (
+    LLMInputs,
+    OpenAICompatibleAPI,
+    OpenAICompatibleChatAPI,
+    OpenAICompatibleCompletionsAPI,
+    OpenAICompatibleEmbeddingsAPI,
+    VLLMOutputs,
+    VLLMOutputsV2,
+)
+from apolo_app_types.protocols.mlflow import MLFlowInputs, MLFlowOutputs
+from apolo_app_types.protocols.postgres import (
+    CrunchyPostgresOutputs,
+    CrunchyPostgresUserCredentials,
+    PGBouncer,
+    PostgresConfig,
+    PostgresInputs,
+    PostgresOutputs,
+)
+from apolo_app_types.protocols.private_gpt import PrivateGPTInputs, PrivateGPTOutputs
+from apolo_app_types.protocols.pycharm import PycharmInputs, PycharmOutputs
+from apolo_app_types.protocols.shell import ShellInputs, ShellOutputs
+from apolo_app_types.protocols.spark_job import SparkJobInputs, SparkJobOutputs
+from apolo_app_types.protocols.stable_diffusion import (
+    SDModel,
+    SDOutputs,
+    StableDiffusionInputs,
+    StableDiffusionOutputs,
+    TextToImgAPI,
+)
+from apolo_app_types.protocols.text_embeddings import (
+    TextEmbeddingsInferenceInputs,
+    TextEmbeddingsInferenceOutputs,
+)
+from apolo_app_types.protocols.vscode import VSCodeInputs, VSCodeOutputs
+from apolo_app_types.protocols.weaviate import WeaviateInputs, WeaviateOutputs
+
+
+__all__ = [
+    "AppInputs",
+    "AppOutputs",
+    "DifyApi",
+    "DifyInputs",
+    "DifyOutputs",
+    "DifyProxy",
+    "DifyWeb",
+    "DifyWorker",
+    "PycharmInputs",
+    "PycharmOutputs",
+    "VSCodeInputs",
+    "VSCodeOutputs",
+    "FooocusInputs",
+    "FooocusOutputs",
+    "JupyterInputs",
+    "JupyterOutputs",
+    "LLMInputs",
+    "VLLMOutputs",
+    "MLFlowInputs",
+    "MLFlowOutputs",
+    "PostgresInputs",
+    "CrunchyPostgresOutputs",
+    "ShellInputs",
+    "ShellOutputs",
+    "SDOutputs",
+    "StableDiffusionInputs",
+    "TextEmbeddingsInferenceInputs",
+    "TextEmbeddingsInferenceOutputs",
+    "WeaviateInputs",
+    "WeaviateOutputs",
+    "OpenAICompatibleEmbeddingsAPI",
+    "OpenAICompatibleAPI",
+    "OpenAICompatibleChatAPI",
+    "OpenAICompatibleCompletionsAPI",
+    "TextToImgAPI",
+    "CrunchyPostgresUserCredentials",
+    "SDModel",
+    "BasicAuth",
+    "ApoloDeployInputs",
+    "ApoloDeployOutputs",
+    "JupyterTypes",
+    "PrivateGPTInputs",
+    "PrivateGPTOutputs",
+    "ApoloSecret",
+    "StrOrSecret",
+    "OptionalStrOrSecret",
+    "StableDiffusionOutputs",
+    "HuggingFaceModel",
+    "VLLMOutputsV2",
+    "AppInputsDeployer",
+    "PGBouncer",
+    "PostgresConfig",
+    "DockerHubInputs",
+    "DockerHubOutputs",
+    "DockerConfigModel",
+    "ApoloFilesMount",
+    "HuggingFaceCacheInputs",
+    "HuggingFaceCacheOutputs",
+    "CustomDeploymentInputs",
+    "CustomDeploymentOutputs",
+    "ContainerImage",
+    "Container",
+    "Service",
+    "Env",
+    "AppOutputsDeployer",
+    "PostgresOutputs",
+    "SparkJobInputs",
+    "SparkJobOutputs",
+    "FooocusAppInputs",
+    "ApoloFilesMount",
+    "Bucket",
+]

apolo_app_types/app_types.py

@@ -0,0 +1,70 @@
+import enum
+
+from apolo_app_types import StableDiffusionInputs
+from apolo_app_types.protocols.common import AppInputs
+from apolo_app_types.protocols.dockerhub import DockerHubInputs
+from apolo_app_types.protocols.huggingface_cache import (
+    HuggingFaceCacheInputs,
+)
+from apolo_app_types.protocols.llm import LLMInputs
+from apolo_app_types.protocols.spark_job import SparkJobInputs
+from apolo_app_types.protocols.weaviate import WeaviateInputs
+
+
+class AppType(enum.StrEnum):
+    PostgreSQL = "postgresql"
+    TextEmbeddingsInference = "text-embeddings-inference"
+    LLMInference = "llm-inference"
+    PrivateGPT = "private-gpt"
+    Dify = "dify"
+    StableDiffusion = "stable-diffusion"
+    Weaviate = "weaviate"
+    Fooocus = "fooocus"
+    Jupyter = "jupyter"
+    VSCode = "vscode"
+    Pycharm = "pycharm"
+    MLFlow = "mlflow"
+    Shell = "shell"
+    ApoloDeploy = "apolo-deploy"
+    DockerHub = "dockerhub"
+    HuggingFaceCache = "huggingface-cache"
+    CustomDeployment = "custom-deployment"
+    SparkJob = "spark-job"
+
+    def __repr__(self) -> str:
+        return str(self)
+
+    def deploys_as_job(self) -> bool:
+        return self in {
+            AppType.PrivateGPT,
+            AppType.Fooocus,
+            AppType.Jupyter,
+            AppType.VSCode,
+            AppType.Pycharm,
+            AppType.MLFlow,
+            AppType.Shell,
+            AppType.ApoloDeploy,
+        }
+
+    def is_appless(self) -> bool:
+        return self in {
+            AppType.HuggingFaceCache,
+        }
+
+    @classmethod
+    def from_app_inputs(cls, inputs: AppInputs) -> "AppType":
+        if isinstance(inputs, LLMInputs):
+            return AppType.LLMInference
+        if isinstance(inputs, WeaviateInputs):
+            return AppType.Weaviate
+        if isinstance(inputs, StableDiffusionInputs):
+            return AppType.StableDiffusion
+        if isinstance(inputs, DockerHubInputs):
+            return AppType.DockerHub
+        if isinstance(inputs, HuggingFaceCacheInputs):
+            return AppType.HuggingFaceCache
+        if isinstance(inputs, SparkJobInputs):
+            return AppType.SparkJob
+
+        error_message = f"Unsupported input type: {type(inputs).__name__}"
+        raise ValueError(error_message)

apolo_app_types/cli.py

@@ -0,0 +1,50 @@
+import asyncio
+import json
+import logging
+import os
+import sys
+
+import click
+
+from apolo_app_types.outputs.update_outputs import update_app_outputs
+
+
+log_level = os.getenv("LOG_LEVEL", "INFO").upper()
+
+logging.basicConfig(
+    level=log_level,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+    handlers=[logging.StreamHandler(sys.stdout)],
+)
+
+logger = logging.getLogger(__name__)
+
+
+@click.group()
+def cli() -> None:
+    pass
+
+
+@cli.command("update-outputs", context_settings={"ignore_unknown_options": True})
+@click.argument("helm_outputs_json", type=str)
+def update_outputs(
+    helm_outputs_json: str,
+) -> None:
+    try:
+        logger.info("Helm input: %s", helm_outputs_json)
+        helm_outputs_dict = json.loads(helm_outputs_json)
+        logger.info("Helm outputs: %s", helm_outputs_dict)
+        result = asyncio.run(update_app_outputs(helm_outputs_dict))
+        if not result:
+            m = "Failed to run update_app_outputs"
+            raise Exception(m)
+    except json.JSONDecodeError as e:
+        logger.error("Failed to parse JSON input: %s", e)
+        sys.exit(1)
+    except Exception as e:
+        logger.error("An error occurred: %s", e)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    cli()

apolo_app_types/clients/kube.py

@@ -0,0 +1,106 @@
+import logging
+import typing
+from pathlib import Path
+
+from kubernetes import client, config  # type: ignore
+from kubernetes.client.rest import ApiException  # type: ignore
+
+
+logger = logging.getLogger(__name__)
+
+SERVICE_ACC_NAMESPACE_FILE = "/var/run/secrets/kubernetes.io/serviceaccount/namespace"
+
+
+def get_current_namespace() -> str:
+    """
+    Retrieve the current namespace from the Kubernetes service account namespace file.
+    """
+    try:
+        with Path.open(Path(SERVICE_ACC_NAMESPACE_FILE)) as f:
+            return f.read().strip()
+    except FileNotFoundError:
+        logger.error("Namespace file not found. Are you running in a Kubernetes pod?")
+        raise
+    except Exception as e:
+        err_msg = f"Error while reading namespace file: {e}"
+        logger.error(err_msg)
+        raise
+
+
+async def get_ingresses_as_dict(label_selectors: str) -> dict[str, typing.Any]:
+    try:
+        config.load_incluster_config()
+
+        networking_v1 = client.NetworkingV1Api()
+        namespace = get_current_namespace()
+        ingresses = networking_v1.list_namespaced_ingress(
+            namespace=namespace, label_selector=label_selectors
+        )
+
+        return client.ApiClient().sanitize_for_serialization(ingresses)
+
+    except ApiException as e:
+        err_msg = (
+            f"Exception when calling NetworkingV1Api->list_namespaced_ingress: {e}"
+        )
+        logger.error(err_msg)
+        raise e
+
+
+async def get_services_by_label(label_selectors: str) -> dict[str, typing.Any]:
+    try:
+        config.load_incluster_config()
+
+        v1 = client.CoreV1Api()
+        namespace = get_current_namespace()
+        services = v1.list_namespaced_service(
+            namespace=namespace, label_selector=label_selectors
+        )
+
+        return client.ApiClient().sanitize_for_serialization(services)
+
+    except ApiException as e:
+        err_msg = f"Exception when calling CoreV1Api->list_namespaced_service: {e}"
+        logger.error(err_msg)
+        raise e
+
+
+async def get_services(match_labels: dict[str, str]) -> list[dict[str, typing.Any]]:
+    label_selectors = ",".join(f"{k}={v}" for k, v in match_labels.items())
+    get_svc_stdout = await get_services_by_label(label_selectors)
+
+    return get_svc_stdout["items"]
+
+
+async def get_service_host_port(match_labels: dict[str, str]) -> tuple[str, str]:
+    services = await get_services(match_labels)
+    if not services:
+        msg = f"Service with labels {match_labels} not found"
+        raise Exception(msg)
+    if len(services) > 1:
+        msg = f"Multiple services with labels {match_labels} found"
+        logger.warning(msg)
+
+    service = services[0]
+    host = f"{service['metadata']['name']}.{service['metadata']['namespace']}"
+    post = str(service["spec"]["ports"][0]["port"])
+
+    return host, post
+
+
+async def get_secret(label: str) -> typing.Any:
+    try:
+        config.load_incluster_config()
+
+        v1 = client.CoreV1Api()
+        namespace = get_current_namespace()
+
+        return v1.list_namespaced_secret(
+            namespace=namespace,
+            label_selector=label,
+        )
+
+    except ApiException as e:
+        err_msg = f"Exception when calling CoreV1Api->read_namespaced_secret: {e}"
+        logger.error(err_msg)
+        raise e

apolo_app_types/helm/apps/__init__.py

@@ -0,0 +1,14 @@
+from .base import BaseChartValueProcessor
+from .common import parse_chart_values_simple
+from .custom_deployment import CustomDeploymentChartValueProcessor
+from .llm import LLMChartValueProcessor
+from .stable_diffusion import StableDiffusionChartValueProcessor
+
+
+__all__ = [
+    "BaseChartValueProcessor",
+    "LLMChartValueProcessor",
+    "StableDiffusionChartValueProcessor",
+    "parse_chart_values_simple",
+    "CustomDeploymentChartValueProcessor",
+]

apolo_app_types/helm/apps/base.py

@@ -0,0 +1,32 @@
+import abc
+import logging
+import typing as t
+
+import apolo_sdk
+
+from apolo_app_types import AppInputs
+
+
+logger = logging.getLogger()
+
+AppInputT = t.TypeVar("AppInputT", bound="AppInputs")
+
+
+class BaseChartValueProcessor(abc.ABC, t.Generic[AppInputT]):
+    def __init__(self, client: apolo_sdk.Client):
+        self.client = client
+
+    async def gen_extra_helm_args(self, *_: t.Any) -> list[str]:
+        return ["--timeout", "15m", "--dependency-update"]
+
+    @abc.abstractmethod
+    async def gen_extra_values(
+        self,
+        input_: AppInputT,
+        app_name: str,
+        namespace: str,
+        app_secrets_name: str,
+        *args: t.Any,
+        **kwargs: t.Any,
+    ) -> dict[str, t.Any]:
+        raise NotImplementedError

apolo_app_types/helm/apps/common.py

@@ -0,0 +1,264 @@
+import json
+import logging
+import os
+import re
+import typing as t
+from copy import deepcopy
+from decimal import Decimal
+
+import apolo_sdk
+import yaml
+from apolo_sdk import Preset
+
+from apolo_app_types.helm.apps.ingress import get_ingress_values
+from apolo_app_types.protocols.common import (
+    ApoloFilesMount,
+    Ingress,
+    Preset as PresetType,
+)
+
+
+logger = logging.getLogger(__name__)
+
+APOLO_STORAGE_ANNOTATION = "platform.apolo.us/inject-storage"
+
+
+def get_preset(client: apolo_sdk.Client, preset_name: str) -> apolo_sdk.Preset:
+    if os.environ.get("ENV") == "local":
+        return Preset(
+            credits_per_hour=Decimal(1.0),
+            cpu=1,
+            memory=1024,
+            resource_pool_names=("default",),
+            available_resource_pool_names=("default",),
+        )
+    preset = client.config.presets.get(preset_name)
+    if not preset:
+        msg = f"Preset {preset_name} not exist in cluster {client.config.cluster_name}"
+        raise Exception(msg)
+    return preset
+
+
+def preset_to_resources(preset: apolo_sdk.Preset) -> dict[str, t.Any]:
+    requests = {
+        "cpu": f"{preset.cpu * 1000}m",
+        "memory": f"{preset.memory_mb}M",
+    }
+    if preset.nvidia_gpu:
+        requests["nvidia.com/gpu"] = str(preset.nvidia_gpu)
+    if preset.amd_gpu:
+        requests["amd.com/gpu"] = str(preset.amd_gpu)
+
+    return {"requests": requests, "limits": requests.copy()}
+
+
+def get_component_values(preset: Preset, preset_name: str) -> dict[str, t.Any]:
+    return {
+        "labels": {
+            "platform.apolo.us/component": "app",
+            "platform.apolo.us/preset": preset_name,
+        },
+        "resources": preset_to_resources(preset),
+        "tolerations": preset_to_tolerations(preset),
+        "affinity": preset_to_affinity(preset),
+    }
+
+
+def _get_match_expressions(pool_names: list[str]) -> list[dict[str, t.Any]]:
+    return [
+        {
+            "key": "platform.neuromation.io/nodepool",
+            "operator": "In",
+            "values": pool_names,
+        }
+    ]
+
+
+def preset_to_affinity(preset: apolo_sdk.Preset) -> dict[str, t.Any]:
+    affinity = {}
+    if preset.available_resource_pool_names:
+        affinity["nodeAffinity"] = {
+            "requiredDuringSchedulingIgnoredDuringExecution": {
+                "nodeSelectorTerms": [
+                    {
+                        "matchExpressions": _get_match_expressions(
+                            list(preset.available_resource_pool_names)
+                        )
+                    }
+                ]
+            }
+        }
+    return affinity
+
+
+def preset_to_tolerations(preset: apolo_sdk.Preset) -> list[dict[str, t.Any]]:
+    tolerations: list[dict[str, t.Any]] = [
+        {
+            "effect": "NoSchedule",
+            "key": "platform.neuromation.io/job",
+            "operator": "Exists",
+        },
+        {
+            "effect": "NoExecute",
+            "key": "node.kubernetes.io/not-ready",
+            "operator": "Exists",
+            "tolerationSeconds": 300,
+        },
+        {
+            "effect": "NoExecute",
+            "key": "node.kubernetes.io/unreachable",
+            "operator": "Exists",
+            "tolerationSeconds": 300,
+        },
+    ]
+    if preset.amd_gpu:
+        tolerations.append(
+            {"effect": "NoSchedule", "key": "amd.com/gpu", "operator": "Exists"}
+        )
+    if preset.nvidia_gpu:
+        tolerations.append(
+            {"effect": "NoSchedule", "key": "nvidia.com/gpu", "operator": "Exists"}
+        )
+    return tolerations
+
+
+def parse_chart_values_simple(helm_args: list[str]) -> dict[str, t.Any]:
+    chart_values = {}
+    set_re = re.compile(r"--set[\s+,=](.+?)(?= --set|\s|$)")
+
+    for match in set_re.finditer(" ".join(helm_args)):
+        keyvalue = match.group(1).strip()
+        key, value = keyvalue.split("=", 1)
+        chart_values[key] = value
+    return chart_values
+
+
+# TODO: hack - should define specific input models for each helm app
+def get_extra_env_vars_from_job() -> tuple[dict[str, t.Any], list[str]]:
+    """
+    Get extra env vars from job environment.
+    Currently, only HUGGING_FACE_HUB_TOKEN is supported.
+
+    Returns:
+        Tuple[dict[str, t.Any], list[str]]: Tuple of extra env vars and secret strings.
+    """
+    extra_env_vars = {}
+    secret_strings = []
+    hf_token = os.getenv("HUGGING_FACE_HUB_TOKEN")
+    if hf_token:
+        extra_env_vars["HUGGING_FACE_HUB_TOKEN"] = hf_token
+        secret_strings.append(hf_token)
+    return extra_env_vars, secret_strings
+
+
+def set_value_from_dot_notation(
+    data: dict[str, t.Any], key: str, value: t.Any
+) -> dict[str, t.Any]:
+    """
+    Set value in nested dict using dot notation.
+
+    Args:
+        data (dict[str, t.Any]): Nested dict.
+        key (str): Dot notation key.
+        value (t.Any): Value to set.
+
+    Returns:
+        dict[str, t.Any]: Updated nested dict.
+    """
+    data_ref = data
+    keys = key.split(".")
+    for k in keys[:-1]:
+        data = data.setdefault(k, {})
+    data[keys[-1]] = value
+    return data_ref
+
+
+def sanitize_dict_string(
+    values: dict[str, t.Any],
+    secrets: t.Sequence[str] | None = None,
+    keys: t.Sequence[str] | None = None,
+) -> str:
+    keys = keys or []
+    secrets = secrets or []
+    values = deepcopy(values)
+    for key in keys:
+        values = set_value_from_dot_notation(values, key, "****")
+    dict_str = yaml.dump(values)
+    if len(secrets) > 0:
+        sec_re = re.compile(f"({'|'.join(secrets)})")
+        return sec_re.sub("****", dict_str)
+    return dict_str
+
+
+def gen_apolo_storage_integration_annotations(
+    files_mouts: t.Sequence[ApoloFilesMount],
+) -> list[dict[str, str]]:
+    storage_mount_annotations = []
+    for storage_mount in files_mouts:
+        storage_mount_annotations.append(
+            {
+                "storage_uri": storage_mount.storage_uri.path,
+                "mount_path": storage_mount.mount_path.path,
+                "mount_mode": storage_mount.mode.mode.value,
+            }
+        )
+    return storage_mount_annotations
+
+
+def gen_apolo_storage_integration_labels(
+    *,
+    inject_storage: bool = False,
+) -> dict[str, str]:
+    if inject_storage:
+        return {APOLO_STORAGE_ANNOTATION: "true"}
+    return {}
+
+
+def append_apolo_storage_integration_annotations(
+    current_annotations: dict[str, t.Any], files_mounts: t.Sequence[ApoloFilesMount]
+) -> dict[str, str]:
+    """
+    Returns a new dict with the storage annotations appended to the current annotations.
+    """
+    cur_annot = deepcopy(current_annotations)
+    cur_apolo_annotation_str: str | None = cur_annot.get(APOLO_STORAGE_ANNOTATION)
+    if cur_apolo_annotation_str:
+        current_list = json.loads(cur_apolo_annotation_str)
+    else:
+        current_list = []
+
+    new_annotations = gen_apolo_storage_integration_annotations(files_mounts)
+    current_list.extend(new_annotations)
+    cur_annot[APOLO_STORAGE_ANNOTATION] = json.dumps(current_list)
+    return cur_annot
+
+
+async def gen_extra_values(
+    apolo_client: apolo_sdk.Client,
+    preset_type: PresetType,
+    ingress: Ingress | None = None,
+    namespace: str | None = None,
+) -> dict[str, t.Any]:
+    preset_name = preset_type.name
+    if not preset_name:
+        logger.warning("No preset_name found in helm args.")
+        return {}
+
+    preset = get_preset(apolo_client, preset_name)
+    tolerations_vals = preset_to_tolerations(preset)
+    affinity_vals = preset_to_affinity(preset)
+    resources_vals = preset_to_resources(preset)
+    ingress_vals: dict[str, t.Any] = {}
+    if ingress:
+        if not namespace:
+            exception_msg = "Namespace is required when ingress is provided."
+            raise ValueError(exception_msg)
+        ingress_vals = await get_ingress_values(apolo_client, ingress, namespace)
+
+    return {
+        "preset_name": preset_name,
+        "resources": resources_vals,
+        "tolerations": tolerations_vals,
+        "affinity": affinity_vals,
+        **ingress_vals,
+    }