flyte 0.0.1b0__py3-none-any.whl → 2.0.0b46__py3-none-any.whl

flyte/app/_runtime/app_serde.py

@@ -0,0 +1,383 @@
+"""
+Serialization module for AppEnvironment to AppIDL conversion.
+
+This module provides functionality to serialize an AppEnvironment object into
+the AppIDL protobuf format, using SerializationContext for configuration.
+"""
+
+from __future__ import annotations
+
+from copy import deepcopy
+from dataclasses import replace
+from typing import List, Optional, Union
+
+from flyteidl2.app import app_definition_pb2
+from flyteidl2.common import runtime_version_pb2
+from flyteidl2.core import literals_pb2, tasks_pb2
+from google.protobuf.duration_pb2 import Duration
+
+import flyte
+import flyte.io
+from flyte._internal.runtime.resources_serde import get_proto_extended_resources, get_proto_resources
+from flyte._internal.runtime.task_serde import get_security_context, lookup_image_in_cache
+from flyte._logging import logger
+from flyte.app import AppEnvironment, Parameter, Scaling
+from flyte.app._parameter import _DelayedValue
+from flyte.models import SerializationContext
+from flyte.syncify import syncify
+
+
+def get_proto_container(
+    app_env: AppEnvironment,
+    serialization_context: SerializationContext,
+    parameter_overrides: list[Parameter] | None = None,
+) -> tasks_pb2.Container:
+    """
+    Construct the container specification.
+
+    Args:
+        app_env: The app environment
+        serialization_context: Serialization context
+        parameter_overrides: Parameter overrides to apply to the app environment.
+    Returns:
+        Container protobuf message
+    """
+    from flyte import Image
+
+    env = [literals_pb2.KeyValuePair(key=k, value=v) for k, v in app_env.env_vars.items()] if app_env.env_vars else None
+    resources = get_proto_resources(app_env.resources)
+
+    if app_env.image == "auto":
+        img = Image.from_debian_base()
+    elif isinstance(app_env.image, str):
+        img = Image.from_base(app_env.image)
+    else:
+        img = app_env.image
+
+    env_name = app_env.name
+    img_uri = lookup_image_in_cache(serialization_context, env_name, img)
+
+    p = app_env.get_port()
+    container_ports = [tasks_pb2.ContainerPort(container_port=p.port, name=p.name)]
+
+    return tasks_pb2.Container(
+        image=img_uri,
+        command=app_env.container_cmd(serialization_context, parameter_overrides),
+        args=app_env.container_args(serialization_context),
+        resources=resources,
+        ports=container_ports,
+        env=env,
+    )
+
+
+def _sanitize_resource_name(resource: tasks_pb2.Resources.ResourceEntry) -> str:
+    """
+    Sanitize resource name for Kubernetes compatibility.
+
+    Args:
+        resource: Resource entry
+
+    Returns:
+        Sanitized resource name
+    """
+    return tasks_pb2.Resources.ResourceName.Name(resource.name).lower().replace("_", "-")
+
+
+def _serialized_pod_spec(
+    app_env: AppEnvironment,
+    pod_template: flyte.PodTemplate,
+    serialization_context: SerializationContext,
+) -> dict:
+    """
+    Convert pod spec into a dict for serialization.
+
+    Args:
+        app_env: The app environment
+        pod_template: Pod template specification
+        serialization_context: Serialization context
+
+    Returns:
+        Dictionary representation of the pod spec
+    """
+    from kubernetes.client import ApiClient
+    from kubernetes.client.models import V1Container, V1ContainerPort, V1EnvVar, V1ResourceRequirements
+
+    pod_template = deepcopy(pod_template)
+
+    if pod_template.pod_spec is None:
+        return {}
+
+    if pod_template.primary_container_name != "app":
+        msg = "Primary container name must be 'app'"
+        raise ValueError(msg)
+
+    containers: list[V1Container] = pod_template.pod_spec.containers
+    primary_exists = any(container.name == pod_template.primary_container_name for container in containers)
+
+    if not primary_exists:
+        msg = "Primary container does not exist with name 'app'"
+        raise ValueError(msg)
+
+    final_containers = []
+
+    # Process containers
+    for container in containers:
+        img = container.image
+        if isinstance(img, flyte.Image):
+            img = lookup_image_in_cache(serialization_context, container.name, img)
+        container.image = img
+
+        if container.name == pod_template.primary_container_name:
+            container.args = app_env.container_args(serialization_context)
+            container.command = app_env.container_cmd(serialization_context)
+
+            limits, requests = {}, {}
+            resources = get_proto_resources(app_env.resources)
+            if resources:
+                for resource in resources.limits:
+                    limits[_sanitize_resource_name(resource)] = resource.value
+                for resource in resources.requests:
+                    requests[_sanitize_resource_name(resource)] = resource.value
+
+                resource_requirements = V1ResourceRequirements(limits=limits, requests=requests)
+
+                if limits or requests:
+                    container.resources = resource_requirements
+
+            if app_env.env_vars:
+                container.env = [V1EnvVar(name=k, value=v) for k, v in app_env.env_vars.items()] + (container.env or [])
+
+            _port = app_env.get_port()
+            container.ports = [V1ContainerPort(container_port=_port.port, name=_port.name)] + (container.ports or [])
+
+        final_containers.append(container)
+
+    pod_template.pod_spec.containers = final_containers
+    return ApiClient().sanitize_for_serialization(pod_template.pod_spec)
+
+
+def _get_k8s_pod(
+    app_env: AppEnvironment,
+    pod_template: flyte.PodTemplate,
+    serialization_context: SerializationContext,
+) -> tasks_pb2.K8sPod:
+    """
+    Convert pod_template into a K8sPod IDL.
+
+    Args:
+        app_env: The app environment
+        pod_template: Pod template specification
+        serialization_context: Serialization context
+
+    Returns:
+        K8sPod protobuf message
+    """
+    import json
+
+    from google.protobuf.json_format import Parse
+    from google.protobuf.struct_pb2 import Struct
+
+    pod_spec_dict = _serialized_pod_spec(app_env, pod_template, serialization_context)
+    pod_spec_idl = Parse(json.dumps(pod_spec_dict), Struct())
+
+    metadata = tasks_pb2.K8sObjectMetadata(
+        labels=pod_template.labels,
+        annotations=pod_template.annotations,
+    )
+    return tasks_pb2.K8sPod(pod_spec=pod_spec_idl, metadata=metadata)
+
+
+def _get_scaling_metric(
+    metric: Optional[Union[Scaling.Concurrency, Scaling.RequestRate]],
+) -> Optional[app_definition_pb2.ScalingMetric]:
+    """
+    Convert scaling metric to protobuf format.
+
+    Args:
+        metric: Scaling metric (Concurrency or RequestRate)
+
+    Returns:
+        ScalingMetric protobuf message or None
+    """
+
+    if metric is None:
+        return None
+
+    if isinstance(metric, Scaling.Concurrency):
+        return app_definition_pb2.ScalingMetric(concurrency=app_definition_pb2.Concurrency(val=metric.val))
+    elif isinstance(metric, Scaling.RequestRate):
+        return app_definition_pb2.ScalingMetric(request_rate=app_definition_pb2.RequestRate(val=metric.val))
+
+    return None
+
+
+async def _materialize_parameters_with_delayed_values(parameters: List[Parameter]) -> List[Parameter]:
+    """
+    Materialize the parameters that contain delayed values. This is important for both
+    serializing the parameter for the container command and for the app idl parameters collection.
+
+    Args:
+        parameters: The parameters to materialize.
+
+    Returns:
+        The materialized parameters.
+    """
+    _parameters = []
+    for param in parameters:
+        if isinstance(param.value, _DelayedValue):
+            logger.info(f"Materializing {param.name} with delayed values of type {param.value.type}")
+            value = await param.value.get()
+            assert isinstance(value, (str, flyte.io.File, flyte.io.Dir)), (
+                f"Materialized value must be a string, file or directory, found {type(value)}"
+            )
+            _parameters.append(replace(param, value=await param.value.get()))
+        else:
+            _parameters.append(param)
+    return _parameters
+
+
+async def translate_parameters(parameters: List[Parameter]) -> app_definition_pb2.InputList:
+    """
+    Translate parameters to protobuf format.
+
+    Returns:
+        InputList protobuf message
+    """
+    if not parameters:
+        return app_definition_pb2.InputList()
+
+    parameters_list = []
+    for param in parameters:
+        if isinstance(param.value, str):
+            parameters_list.append(app_definition_pb2.Input(name=param.name, string_value=param.value))
+        elif isinstance(param.value, flyte.io.File):
+            parameters_list.append(app_definition_pb2.Input(name=param.name, string_value=str(param.value.path)))
+        elif isinstance(param.value, flyte.io.Dir):
+            parameters_list.append(app_definition_pb2.Input(name=param.name, string_value=str(param.value.path)))
+        else:
+            raise ValueError(f"Unsupported parameter value type: {type(param.value)}")
+    return app_definition_pb2.InputList(items=parameters_list)
+
+
+@syncify
+async def translate_app_env_to_idl(
+    app_env: AppEnvironment,
+    serialization_context: SerializationContext,
+    parameter_overrides: list[Parameter] | None = None,
+    desired_state: app_definition_pb2.Spec.DesiredState = app_definition_pb2.Spec.DesiredState.DESIRED_STATE_ACTIVE,
+) -> app_definition_pb2.App:
+    """
+    Translate an AppEnvironment to AppIDL protobuf format.
+
+    This is the main entry point for serializing an AppEnvironment object into
+    the AppIDL protobuf format.
+
+    Args:
+        app_env: The app environment to serialize
+        serialization_context: Serialization context containing org, project, domain, version, etc.
+        parameter_overrides: Parameter overrides to apply to the app environment.
+        desired_state: Desired state of the app (ACTIVE, INACTIVE, etc.)
+
+    Returns:
+        AppIDL protobuf message
+    """
+    # Build security context
+    task_sec_ctx = get_security_context(app_env.secrets)
+    allow_anonymous = False
+    if not app_env.requires_auth:
+        allow_anonymous = True
+
+    security_context = None
+    if task_sec_ctx or allow_anonymous:
+        security_context = app_definition_pb2.SecurityContext(
+            run_as=task_sec_ctx.run_as if task_sec_ctx else None,
+            secrets=task_sec_ctx.secrets if task_sec_ctx else [],
+            allow_anonymous=allow_anonymous,
+        )
+
+    # Build autoscaling config
+    scaling_metric = _get_scaling_metric(app_env.scaling.metric)
+
+    dur = None
+    if app_env.scaling.scaledown_after:
+        dur = Duration()
+        dur.FromTimedelta(app_env.scaling.scaledown_after)
+
+    min_replicas, max_replicas = app_env.scaling.get_replicas()
+    autoscaling = app_definition_pb2.AutoscalingConfig(
+        replicas=app_definition_pb2.Replicas(min=min_replicas, max=max_replicas),
+        scaledown_period=dur,
+        scaling_metric=scaling_metric,
+    )
+
+    # Build spec based on image type
+    parameters = await _materialize_parameters_with_delayed_values(parameter_overrides or app_env.parameters)
+    container = None
+    pod = None
+    if app_env.pod_template:
+        if isinstance(app_env.pod_template, str):
+            raise NotImplementedError("PodTemplate as str is not supported yet")
+        pod = _get_k8s_pod(
+            app_env,
+            app_env.pod_template,
+            serialization_context,
+        )
+    elif app_env.image:
+        container = get_proto_container(
+            app_env,
+            serialization_context,
+            parameter_overrides=parameters,
+        )
+    else:
+        msg = "image must be a str, Image, or PodTemplate"
+        raise ValueError(msg)
+
+    ingress = app_definition_pb2.IngressConfig(
+        private=False,
+        subdomain=app_env.domain.subdomain if app_env.domain else None,
+        cname=app_env.domain.custom_domain if app_env.domain else None,
+    )
+
+    # Build links
+    links = None
+    if app_env.links:
+        links = [
+            app_definition_pb2.Link(path=link.path, title=link.title, is_relative=link.is_relative)
+            for link in app_env.links
+        ]
+
+    # Build profile
+    profile = app_definition_pb2.Profile(
+        type=app_env.type,
+        short_description=app_env.description,
+    )
+
+    # Build the full App IDL
+    return app_definition_pb2.App(
+        metadata=app_definition_pb2.Meta(
+            id=app_definition_pb2.Identifier(
+                org=serialization_context.org,
+                project=serialization_context.project,
+                domain=serialization_context.domain,
+                name=app_env.name,
+            ),
+        ),
+        spec=app_definition_pb2.Spec(
+            desired_state=desired_state,
+            ingress=ingress,
+            autoscaling=autoscaling,
+            security_context=security_context,
+            cluster_pool=app_env.cluster_pool,
+            extended_resources=get_proto_extended_resources(app_env.resources),
+            runtime_metadata=runtime_version_pb2.RuntimeMetadata(
+                type=runtime_version_pb2.RuntimeMetadata.RuntimeType.FLYTE_SDK,
+                version=flyte.version(),
+                flavor="python",
+            ),
+            profile=profile,
+            links=links,
+            container=container,
+            pod=pod,
+            inputs=await translate_parameters(parameters),
+        ),
+    )

flyte/app/_types.py

@@ -0,0 +1,113 @@
+from dataclasses import dataclass
+from datetime import timedelta
+from typing import Optional, Tuple, Union
+
+import rich.repr
+
+INVALID_APP_PORTS = [8012, 8022, 8112, 9090, 9091]
+
+
+@rich.repr.auto
+@dataclass(frozen=True)
+class Port:
+    port: int
+    name: Optional[str] = None
+
+    def __post_init__(self):
+        if self.port in INVALID_APP_PORTS:
+            invalid_ports = ", ".join(str(p) for p in INVALID_APP_PORTS)
+            msg = f"port {self.port} is not allowed. Please do not use ports: {invalid_ports}"
+            raise ValueError(msg)
+
+
+@rich.repr.auto
+@dataclass(frozen=True)
+class Link:
+    """Custom links to add to the app"""
+
+    path: str
+    title: str
+    is_relative: bool = False
+
+
+@rich.repr.auto
+@dataclass
+class Scaling:
+    @dataclass(frozen=True)
+    class Concurrency:
+        """
+        Use this to specify the concurrency metric for autoscaling, i.e. the number of concurrent requests at a replica
+         at which to scale up.
+        """
+
+        val: int
+
+        def __post_init__(self):
+            if self.val < 1:
+                raise ValueError("Concurrency must be greater than or equal to 1")
+
+    @dataclass
+    class RequestRate:
+        """
+        Use this to specify the request rate metric for autoscaling, i.e. the number of requests per second at a replica
+         at which to scale up.
+        """
+
+        val: int
+
+        def __post_init__(self):
+            if self.val < 1:
+                raise ValueError("Request rate must be greater than or equal to 1")
+
+    """Number of replicas to run. Can be a single int or a tuple of two ints representing the min and max replicas."""
+    replicas: Union[int, Tuple[int, int]] = (0, 1)
+
+    """Metric to use for autoscaling. Can be a concurrency or request rate."""
+    metric: Optional[Union[Concurrency, RequestRate]] = None
+
+    """Time to wait after the last request before scaling down. Can be a number of seconds or a timedelta."""
+    scaledown_after: int | timedelta | None = None
+
+    def __post_init__(self):
+        if isinstance(self.replicas, int):
+            if self.replicas < 0:
+                raise ValueError("replicas must be greater than or equal to 0")
+            self.replicas = (self.replicas, self.replicas)
+        elif isinstance(self.replicas, tuple):
+            if len(self.replicas) != 2:
+                raise ValueError("replicas tuple must be of length 2")
+            min_replicas, max_replicas = self.replicas
+            if min_replicas < 0:
+                raise ValueError("min_replicas must be greater than or equal to 0")
+            if max_replicas < 1 or max_replicas < min_replicas:
+                raise ValueError("max_replicas must be greater than or equal to 1 and min_replicas")
+        else:
+            raise TypeError("replicas must be an int or a tuple of two ints")
+
+        if self.metric:
+            if not isinstance(self.metric, (Scaling.Concurrency, Scaling.RequestRate)):
+                raise TypeError("metric must be an instance of Scaling.Concurrency or Scaling.RequestRate")
+
+        if self.scaledown_after:
+            if isinstance(self.scaledown_after, int):
+                self.scaledown_after = timedelta(seconds=self.scaledown_after)
+            elif not isinstance(self.scaledown_after, timedelta):
+                raise TypeError("scaledown_after must be an int or a timedelta")
+
+    def get_replicas(self) -> Tuple[int, int]:
+        if isinstance(self.replicas, int):
+            return self.replicas, self.replicas
+        return self.replicas
+
+
+@rich.repr.auto
+@dataclass
+class Domain:
+    # SubDomain config
+
+    """Subdomain to use for the domain. If not set, the default subdomain will be used."""
+
+    subdomain: Optional[str] = None
+
+    """Custom domain to use for the domain. If not set, the default custom domain will be used."""
+    custom_domain: Optional[str] = None

flyte/app/extras/__init__.py

@@ -0,0 +1,9 @@
+from ._auth_middleware import (
+    FastAPIPassthroughAuthMiddleware,
+)
+from ._fastapi import FastAPIAppEnvironment
+
+__all__ = [
+    "FastAPIAppEnvironment",
+    "FastAPIPassthroughAuthMiddleware",
+]