apolo-app-types 25.4.3__tar.gz

apolo_app_types-25.4.3/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.3
+Name: apolo-app-types
+Version: 25.4.3
+Summary: Apolo Platform App Types.
+License: Apache 2
+Author: Apolo.us
+Requires-Python: >=3.9.0,<4.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development
+Classifier: Topic :: Utilities
+Requires-Dist: apolo-sdk (>=24.12.3,<25.0.0)
+Requires-Dist: click (>=8.0.3,<9.0.0)
+Requires-Dist: httpx (>=0.28.0,<0.29.0)
+Requires-Dist: kubernetes (>=31.0.0,<32.0.0)
+Requires-Dist: pydantic (>=2.9.2,<3.0.0)
+Requires-Dist: pyyaml (>=6.0.2,<7.0.0)
+Requires-Dist: types-PyYAML (>=6.0.12.20241230,<7.0.0.0)
+Requires-Dist: yarl (>=1.18.3,<2.0.0)
+Description-Content-Type: text/markdown
+
+# Preface
+
+Apolo app types https://apolo.us/.
+

apolo_app_types-25.4.3/README.md

@@ -0,0 +1,3 @@
+# Preface
+
+Apolo app types https://apolo.us/.

apolo_app_types-25.4.3/pyproject.toml

@@ -0,0 +1,163 @@
+[build-system]
+requires = ["poetry-core>=1.0.0", "poetry-dynamic-versioning>=1.0.0,<2.0.0"]
+build-backend = "poetry_dynamic_versioning.backend"
+
+[project]
+name = "apolo-app-types"
+description = "Apolo Platform App Types."
+readme = "README.md"
+license = "Apache 2"
+authors = [{name = "Apolo.us"}]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Information Technology",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Software Development",
+    "Topic :: Utilities"
+]
+dynamic = []
+requires-python = ">=3.9.0,<4.0"
+version = "25.4.3"
+
+[project.scripts]
+app-types = "apolo_app_types.cli:cli"
+
+[tool.poetry]
+packages = [
+  { include = "apolo_app_types", from = "src" },
+]
+
+[tool.poetry.dependencies]
+apolo-sdk = "^24.12.3"
+click = "^8.0.3"
+httpx = "^0.28.0"
+kubernetes = "^31.0.0"
+pydantic = "^2.9.2"
+pyyaml = "^6.0.2"
+types-PyYAML = "^6.0.12.20241230"
+yarl = "^1.18.3"
+
+[tool.poetry-dynamic-versioning]
+enable = false
+vcs = "git"
+
+[tool.poetry.group.dev]
+optional = true
+
+[tool.poetry.group.dev.dependencies]
+pre-commit = "^4.0.1"
+pytest = "^8.3.4"
+pytest-asyncio = "^0.25.3"
+pytest-cov = "^6.0.0"
+mypy = "^1.15.0"
+
+[tool.ruff]
+target-version = "py311"
+lint.select = [
+    "E", "F", "I", "C90", "UP", "B", "ASYNC", "N", "FBT", "A", "C4", "EM", "FA", "ICN",
+    "G", "PIE", "T20", "PYI", "PT", "RET", "PTH"
+]
+lint.ignore = [
+  "A003",  # Class attribute "..." is shadowing a Python builtin
+  "N818"
+]
+
+[tool.ruff.lint.isort.sections]
+ApoloSDK = ["apolo-sdk"]
+
+[tool.ruff.lint.isort]
+combine-as-imports = true
+lines-after-imports = 2
+#profile = "black"
+section-order = ["future", "standard-library", "third-party", "ApoloSDK", "first-party", "local-folder"]
+known-first-party = ["apolo_app_types"]
+known-local-folder = ["tests"]
+
+[tool.mypy]
+check_untyped_defs = true
+disallow_any_generics = true
+disallow_untyped_defs = true
+follow_imports = "silent"
+strict_optional = true
+warn_redundant_casts = true
+warn_unused_ignores = true
+warn_unused_configs = true
+plugins = ['pydantic.mypy']
+
+
+[[tool.mypy.overrides]]
+module = "pytest"
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = "aiodocker.*"
+ignore_missing_imports = true
+
+[tool.flake8]
+extend-exclude = [
+  ".git",
+  ".env",
+  "__pycache__",
+  ".eggs",
+]
+max-line-length = 88
+extend-ignore = [
+  "N801",
+  "N802",
+  "N803",
+  "E252",
+  "W503", # line break before binary operator (conflicts with Black)
+  "E133",
+  "E203", # whitespace before ':' (conflicts with Black)
+  "F541",
+]
+
+[tool.coverage.report]
+fail_under = 0
+skip_empty = true
+sort = "-cover"
+omit = [
+    "build-tools/*",
+    "tests/*",
+]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "session"
+log_cli = false
+log_level = "INFO"
+junit_family = "xunit2"
+testpaths = [
+  "tests/",
+]
+markers = [
+    "e2e",
+    "e2e_job",
+    "require_admin",
+    "xdist_group",
+]
+filterwarnings = [
+    "error",
+    "ignore:.*PROTOCOL_TLS is deprecated:DeprecationWarning:apolo_sdk",
+    "ignore:.*PROTOCOL_TLS is deprecated:DeprecationWarning:tests",
+    "ignore:.*PROTOCOL_TLS is deprecated:DeprecationWarning:aiohttp",
+    "ignore:Inheritance class AuthorizedSession from ClientSession is discouraged:DeprecationWarning:google",
+    "ignore:returning HTTPException object is deprecated.+:DeprecationWarning:aiodocker",
+    "ignore:ssl_context is deprecated.+:DeprecationWarning:aiodocker",
+    "ignore:the imp module is deprecated.+:DeprecationWarning:past",
+    "ignore:Flags not at the start of the expression.+:DeprecationWarning:cookiecutter",
+    "ignore:Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated, and in 3.8 it will stop working:DeprecationWarning:jinja2",
+    "ignore:(rm_rf) error removing.+:UserWarning:pytest",
+    "ignore::ResourceWarning:asyncio",
+    "ignore::UserWarning:_pytest",
+    "ignore:The loop argument is deprecated*:DeprecationWarning:asyncio",
+    "ignore:'autocompletion' is renamed to 'shell_complete'.+:DeprecationWarning:click",
+    "ignore:.*pkg_resources.declare_namespace.*:DeprecationWarning:pkg_resources",
+]

apolo_app_types-25.4.3/src/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-25.4.3/src/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-25.4.3/src/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-25.4.3/src/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-25.4.3/src/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-25.4.3/src/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