flytekitplugins-k8sdataservice 1.15.0__tar.gz

flytekitplugins_k8sdataservice-1.15.0/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.2
+Name: flytekitplugins-k8sdataservice
+Version: 1.15.0
+Summary: Flytekit K8s Data Service Plugin
+Author: LinkedIn
+Author-email: shuliang@linkedin.com
+License: apache2
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Requires-Dist: flytekit<2.0.0,>=1.11.0
+Requires-Dist: kubernetes<24.0.0,>=23.6.0
+Requires-Dist: flyteidl<2.0.0,>=1.11.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

flytekitplugins_k8sdataservice-1.15.0/README.md

@@ -0,0 +1,104 @@
+# K8s Stateful Service Plugin
+
+This plugin provides support for Kubernetes StatefulSet and Service integration, enabling seamless provisioning and coordination with any Kubernetes services or Flyte tasks. It is especially suited for deep learning use cases at scale, where distributed and parallelized data loading and caching across nodes are required.
+
+## Features
+- **Predictable and Reliable Endpoints**: The service creates consistent endpoints, facilitating communication between services or tasks within the same Kubernetes cluster.
+- **Reusable Across Runs**: Service tasks can persist across task runs, ensuring consistency. Alternatively, a cleanup sensor can release cluster resources when they are no longer needed.
+- **Conventional Pod Naming**: Pods in the StatefulSet follow a conventional naming pattern. For instance, if the StatefulSet name is `foo` and replicas are set to 2, the pod endpoints will be `foo-0.foo:1234` and `foo-1.foo:1234`. This simplifies endpoint construction for training or inference scripts. For example, gRPC endpoints can directly use `foo-0.foo:1234` and `foo-1.foo:1234`.
+
+## Installation
+
+Install the plugin via pip:
+
+```bash
+pip install flytekitplugins-k8sdataservice
+```
+
+## Usage
+
+Below is an example demonstrating how to provision and run a service in Kubernetes, making it reachable within the cluster.
+
+**Note**: Utility functions are available to generate unique service names that can be reused across training or inference scripts.
+
+### Example Usage
+
+#### Provisioning a Data Service
+```python
+from flytekitplugins.k8sdataservice import DataServiceConfig, DataServiceTask, CleanupSensor
+from utils.infra import gen_infra_name
+from flytekit import kwtypes, Resources, task, workflow
+
+# Generate a unique infrastructure name
+name = gen_infra_name()
+
+def k8s_data_service():
+    gnn_config = DataServiceConfig(
+        Name=name,
+        Requests=Resources(cpu='1', mem='1Gi'),
+        Limits=Resources(cpu='2', mem='2Gi'),
+        Replicas=1,
+        Image="busybox:latest",
+        Command=[
+            "bash",
+            "-c",
+            "echo Hello Flyte K8s Stateful Service! && sleep 3600"
+        ],
+    )
+
+    gnn_task = DataServiceTask(
+        name="K8s Stateful Data Service",
+        inputs=kwtypes(ds=str),
+        task_config=gnn_config,
+    )
+    return gnn_task
+
+# Define a cleanup sensor
+gnn_sensor = CleanupSensor(name="Cleanup")
+
+# Define a workflow to test the data service
+@workflow
+def test_dataservice_wf(name: str):
+    k8s_data_service()(ds="OSS Flyte K8s Data Service Demo") \
+          >> gnn_sensor(
+              release_name=name,
+              cleanup_data_service=True,
+          )
+
+if __name__ == "__main__":
+    out = test_dataservice_wf(name="example")
+    print(f"Running test_dataservice_wf() {out}")
+```
+
+#### Accessing the Data Service
+Other tasks or services that need to access the data service can do so in multiple ways. For example, using environment variables:
+
+```python
+from kubernetes.client import V1PodSpec, V1Container, V1EnvVar
+
+PRIMARY_CONTAINER_NAME = "primary"
+FLYTE_POD_SPEC = V1PodSpec(
+    containers=[
+        V1Container(
+            name=PRIMARY_CONTAINER_NAME,
+            env=[
+                V1EnvVar(name="MY_DATASERVICES", value=f"{name}-0.{name}:40000 {name}-1.{name}:40000"),
+            ],
+        )
+    ],
+)
+
+task_config = MPIJob(
+    launcher=Launcher(replicas=1, pod_template=FLYTE_POD_SPEC),
+    worker=Worker(replicas=1, pod_template=FLYTE_POD_SPEC),
+)
+
+@task(task_config=task_config)
+def mpi_task() -> str:
+    return "your script uses the envs to communicate with the data service "
+```
+
+### Key Points
+- The `DataServiceConfig` defines resource requests, limits, replicas, and the container image/command.
+- The `CleanupSensor` ensures resources are cleaned up when required.
+- The workflow connects the service provisioning and cleanup process for streamlined operations.

flytekitplugins_k8sdataservice-1.15.0/flytekitplugins/k8sdataservice/__init__.py

@@ -0,0 +1,15 @@
+"""
+.. currentmodule:: flytekitplugins.k8sdataservice
+
+This package contains things that are useful when extending Flytekit.
+
+.. autosummary::
+   :template: custom.rst
+   :toctree: generated/
+
+   DataServiceTask
+"""
+
+from .agent import DataServiceAgent  # noqa: F401
+from .sensor import CleanupSensor  # noqa: F401
+from .task import DataServiceConfig, DataServiceTask  # noqa: F401

flytekitplugins_k8sdataservice-1.15.0/flytekitplugins/k8sdataservice/agent.py

@@ -0,0 +1,98 @@
+from dataclasses import dataclass
+from typing import Optional
+
+from flyteidl.core.execution_pb2 import TaskExecution
+from flytekitplugins.k8sdataservice.k8s.manager import K8sManager
+from flytekitplugins.k8sdataservice.task import DataServiceConfig
+
+from flytekit import logger
+from flytekit.extend.backend.base_agent import AgentRegistry, AsyncAgentBase, Resource, ResourceMeta
+from flytekit.models.literals import LiteralMap
+from flytekit.models.task import TaskTemplate
+
+
+@dataclass
+class DataServiceMetadata(ResourceMeta):
+    dataservice_config: DataServiceConfig
+    name: str
+
+
+class DataServiceAgent(AsyncAgentBase):
+    name = "K8s DataService Async Agent"
+
+    def __init__(self):
+        self.k8s_manager = K8sManager()
+        super().__init__(task_type_name="dataservicetask", metadata_type=DataServiceMetadata)
+        self.config = None
+
+    def create(
+        self, task_template: TaskTemplate, output_prefix: str, inputs: Optional[LiteralMap] = None, **kwargs
+    ) -> DataServiceMetadata:
+        graph_engine_config = task_template.custom
+        self.k8s_manager.set_configs(graph_engine_config)
+        logger.info(f"Loaded agent config file {self.config}")
+        existing_release_name = graph_engine_config.get("ExistingReleaseName", None)
+        logger.info(f"The existing data service release name is {existing_release_name}")
+
+        name = ""
+        if existing_release_name is None or existing_release_name == "":
+            logger.info("Creating K8s data service resources...")
+            name = self.k8s_manager.create_data_service()
+            logger.info(f'Data service {name} with image {graph_engine_config["Image"]} completed')
+        else:
+            name = existing_release_name
+            logger.info(f"User configs to use the existing data service release name: {name}.")
+
+        dataservice_config = DataServiceConfig(
+            Name=graph_engine_config.get("Name", None),
+            Image=graph_engine_config["Image"],
+            Command=graph_engine_config["Command"],
+            Cluster=graph_engine_config["Cluster"],
+            ExistingReleaseName=graph_engine_config.get("ExistingReleaseName", None),
+        )
+        metadata = DataServiceMetadata(
+            dataservice_config=dataservice_config,
+            name=name,
+        )
+        logger.info(f"Created DataService metadata {metadata}")
+        return metadata
+
+    def get(self, resource_meta: DataServiceMetadata) -> Resource:
+        logger.info("K8s Data Service get is called")
+        data = resource_meta.dataservice_config
+        data_dict = data.__dict__ if isinstance(data, DataServiceConfig) else data
+        logger.info(f"The data_dict is {data_dict}")
+        self.k8s_manager.set_configs(data_dict)
+        name = data.Name
+        logger.info(f"Get the stateful set name {name}")
+
+        k8s_status = self.k8s_manager.check_stateful_set_status(name)
+        flyte_state = None
+        if k8s_status in ["failed", "timeout", "timedout", "canceled", "skipped", "internal_error"]:
+            flyte_state = TaskExecution.FAILED
+        elif k8s_status in ["done", "succeeded", "success"]:
+            flyte_state = TaskExecution.SUCCEEDED
+        elif k8s_status in ["running", "terminating", "pending"]:
+            flyte_state = TaskExecution.RUNNING
+        else:
+            logger.error(f"Unrecognized state: {k8s_status}")
+        outputs = {
+            "data_service_name": name,
+        }
+        # TODO: Add logs for StatefulSet.
+        return Resource(phase=flyte_state, outputs=outputs)
+
+    def delete(self, resource_meta: DataServiceMetadata):
+        logger.info("DataService delete is called")
+        data = resource_meta.dataservice_config
+
+        data_dict = data.__dict__ if isinstance(data, DataServiceConfig) else data
+        self.k8s_manager.set_configs(data_dict)
+
+        name = resource_meta.name
+        logger.info(f"To delete the DataService (e.g., StatefulSet and Service) with name {name}")
+        self.k8s_manager.delete_stateful_set(name)
+        self.k8s_manager.delete_service(name)
+
+
+AgentRegistry.register(DataServiceAgent())

flytekitplugins_k8sdataservice-1.15.0/flytekitplugins/k8sdataservice/k8s/kube_config.py

@@ -0,0 +1,20 @@
+from kubernetes import config
+
+from flytekit import logger
+
+
+class KubeConfig:
+    def __init__(self):
+        pass
+
+    def load_kube_config(self) -> None:
+        """Load the kubernetes config based on fabric details prior to K8s client usage
+
+        :params target_fabric: fabric on which we are loading configs
+        """
+        try:
+            logger.info("Attempting to load in-cluster configuration.")
+            config.load_incluster_config()  # This will use the service account credentials
+            logger.info("Successfully loaded in-cluster configuration using the agent service account.")
+        except config.ConfigException as e:
+            logger.warning(f"Failed to load in-cluster configuration. {e}")

flytekitplugins_k8sdataservice-1.15.0/flytekitplugins/k8sdataservice/k8s/manager.py

@@ -0,0 +1,219 @@
+import uuid
+
+from flytekitplugins.k8sdataservice.k8s.kube_config import KubeConfig
+from kubernetes import client
+from kubernetes.client.rest import ApiException
+from utils.resources import cleanup_resources, convert_flyte_to_k8s_fields
+
+from flytekit import logger
+
+APPNAME = "service-name"
+DEFAULT_RESOURCES = client.V1ResourceRequirements(
+    requests={"cpu": "2", "memory": "10G"}, limits={"cpu": "6", "memory": "16G"}
+)
+
+
+class K8sManager:
+    def __init__(self):
+        self.config = KubeConfig()
+        self.config.load_kube_config()
+        self.apps_v1_api = client.AppsV1Api()
+        self.core_v1_api = client.CoreV1Api()
+
+    def set_configs(self, data_service_config):
+        self.data_service_config = data_service_config
+        self.labels = {}
+        self.namespace = "flyte"
+        self.name = None
+        self.name = data_service_config.get("Name", None)
+        if self.name is None:
+            self.name = f"k8s-dataservice-{uuid.uuid4().hex[:8]}"
+
+    def create_data_service(self) -> str:
+        svc_name = self.create_service()
+        logger.info(f"Created service: {svc_name}")
+        stateful_set_obj = self.create_stateful_set_object()
+        name = self.create_stateful_set(stateful_set_obj)
+        return name
+
+    def create_stateful_set(self, stateful_set_object) -> str:
+        api_response = None
+        try:
+            api_response = self.apps_v1_api.create_namespaced_stateful_set(
+                namespace=self.namespace, body=stateful_set_object
+            )
+            logger.info(f"Created statefulset in K8s API server: {api_response}")
+        except ApiException as e:
+            logger.error(f"Exception when calling AppsV1Api->create_namespaced_stateful_set: {e}\n")
+            raise
+        return api_response.metadata.name
+
+    def create_stateful_set_object(self):
+        container = self._create_container()
+        template = self._create_pod_template(container)
+        spec = self._create_stateful_set_spec(template)
+        return client.V1StatefulSet(
+            api_version="apps/v1",
+            kind="StatefulSet",
+            metadata=client.V1ObjectMeta(
+                labels=self.labels,
+                name=self.name,
+                annotations={},
+            ),
+            spec=spec,
+        )
+
+    def _create_container(self):
+        ss_replicas = self.data_service_config.get("Replicas", 1)
+        port = self.data_service_config.get("Port", 40000)
+        ss_env = [
+            client.V1EnvVar(name="GE_BASE_PORT", value=str(port)),
+            client.V1EnvVar(name="GE_COUNT", value=str(int(ss_replicas))),
+            client.V1EnvVar(name="SERVER_PORT", value=str(port)),
+        ]
+        return client.V1Container(
+            name=self.name,
+            image=self.data_service_config["Image"],
+            image_pull_policy="IfNotPresent",
+            ports=[client.V1ContainerPort(container_port=port, name="graph-engine")],
+            command=self.data_service_config["Command"],
+            env=ss_env,
+            resources=self.get_resources(),
+        )
+
+    def _create_pod_template(self, container):
+        self.labels.update({"app.kubernetes.io/instance": self.name})
+        return client.V1PodTemplateSpec(
+            metadata=client.V1ObjectMeta(
+                labels=self.labels,
+                annotations={},
+            ),
+            spec=client.V1PodSpec(
+                containers=[container],
+                security_context=client.V1PodSecurityContext(
+                    fs_group=1001,
+                    run_as_group=1001,
+                    run_as_non_root=True,
+                    run_as_user=1001,
+                ),
+            ),
+        )
+
+    def _create_stateful_set_spec(self, template):
+        ss_replicas = self.data_service_config.get("Replicas", 1)
+        return client.V1StatefulSetSpec(
+            replicas=int(ss_replicas),
+            selector=client.V1LabelSelector(
+                match_labels={"app.kubernetes.io/instance": self.name},
+            ),
+            service_name=self.name,
+            template=template,
+        )
+
+    def create_service(self) -> str:
+        namespace = self.namespace
+        logger.info(f"creating a service at namespace {namespace} with name {self.name}")
+        port = self.data_service_config.get("Port", 40000)
+        self.labels.update({"app.kubernetes.io/instance": self.name, "app": APPNAME})
+        body = client.V1Service(
+            api_version="v1",
+            kind="Service",
+            metadata=client.V1ObjectMeta(
+                name=self.name,
+                labels=self.labels,
+                namespace=namespace,
+            ),
+            spec=client.V1ServiceSpec(
+                selector={"app.kubernetes.io/instance": self.name},
+                type="ClusterIP",
+                ports=[
+                    client.V1ServicePort(
+                        port=port,
+                        target_port=port,
+                        name=self.name,
+                    )
+                ],
+            ),
+        )
+        logger.info(
+            f"Service configuration in namespace {namespace} and name {self.name} is completed, posting request to K8s API server..."
+        )
+        api_response = None
+        try:
+            api_response = self.core_v1_api.create_namespaced_service(namespace=namespace, body=body)
+        except ApiException as e:
+            logger.error(f"Exception when calling CoreV1Api->create_namespaced_service: {e}")
+            raise e
+        # This will not happen in K8s API, but in case.
+        if api_response is None or not hasattr(api_response, "metadata") or not hasattr(api_response.metadata, "name"):
+            raise ValueError("Invalid response from Kubernetes API - missing metadata or name")
+        return api_response.metadata.name
+
+    def check_stateful_set_status(self, name) -> str:
+        try:
+            stateful_set = self.apps_v1_api.read_namespaced_stateful_set(name=name, namespace=self.namespace)
+            status = stateful_set.status
+            logger.info(f"StatefulSet status: {status}")
+            conditions = status.conditions if status and status.conditions else []
+            logger.info(f"StatefulSet conditions: {conditions}")
+
+            if status.replicas == 0:
+                logger.info(
+                    f"StatefulSet {name} is pending. replicas: {status.replicas}, available: {status.available_replicas }"
+                )
+                return "pending"
+
+            if status.replicas > 0 and (
+                status.replicas == status.available_replicas or status.replicas == status.ready_replicas
+            ):
+                logger.info(
+                    f"StatefulSet {name} has succeeded. replicas: {status.replicas}, available: {status.available_replicas }"
+                )
+                return "success"
+
+            if status.replicas > 0 and status.available_replicas is not None and status.available_replicas >= 0:
+                logger.info(
+                    f"StatefulSet {name} is running. replicas: {status.replicas}, available: {status.available_replicas }"
+                )
+                return "running"
+
+            logger.info(
+                f"StatefulSet {name} status is unknown. Replicas:  {status.replicas}, available: {status.available_replicas }"
+            )
+            return "failed"
+        except ApiException as e:
+            logger.error(f"Exception when calling AppsV1Api->read_namespaced_stateful_set: {e}")
+            return f"Error checking status of StatefulSet {name}: {e}"
+
+    def delete_stateful_set(self, name: str):
+        try:
+            self.apps_v1_api.delete_namespaced_stateful_set(
+                name=name, namespace=self.namespace, body=client.V1DeleteOptions()
+            )
+            logger.info(f"Deleted StatefulSet: {name}")
+        except ApiException as e:
+            logger.error(f"Exception when calling AppsV1Api->delete_namespaced_stateful_set: {e}")
+
+    def delete_service(self, name: str):
+        try:
+            self.core_v1_api.delete_namespaced_service(
+                name=name, namespace=self.namespace, body=client.V1DeleteOptions()
+            )
+            logger.info(f"Deleted Service: {name}")
+        except ApiException as e:
+            logger.error(f"Exception when calling CoreV1Api->delete_namespaced_service: {e}")
+
+    def get_resources(self) -> client.V1ResourceRequirements:
+        res = DEFAULT_RESOURCES
+        flyteidl_limits = self.data_service_config.get("Limits", None)
+        flyteidl_requests = self.data_service_config.get("Requests", None)
+        logger.info(f"Flyte Resources: limits: {flyteidl_limits} and requests {flyteidl_requests}")
+        if flyteidl_limits is not None:
+            res.limits = convert_flyte_to_k8s_fields(flyteidl_limits)
+            logger.info(f"Resources limits updated is: {res.limits}")
+        if flyteidl_requests is not None:
+            res.requests = convert_flyte_to_k8s_fields(flyteidl_requests)
+            logger.info(f"Resources requests updated is: {res.requests}")
+        cleanup_resources(res)
+        logger.info(f"Resources cleaned up is: {res}")
+        return res

flytekitplugins_k8sdataservice-1.15.0/flytekitplugins/k8sdataservice/sensor.py

@@ -0,0 +1,67 @@
+from flytekitplugins.k8sdataservice.k8s.kube_config import KubeConfig
+from kubernetes import client
+from kubernetes.client.rest import ApiException
+
+from flytekit import logger
+from flytekit.sensor.base_sensor import BaseSensor
+
+TRAININGJOB_API_GROUP = "kubeflow.org"
+VERSION = "v1"
+
+
+class CleanupSensor(BaseSensor):
+    def __init__(self, name: str, namespace: str = "flyte", **kwargs):
+        """
+        Initialize the CleanupSensor class with relevant configurations for monitoring and managing the k8s data service.
+        """
+        super().__init__(name=name, task_type="sensor", **kwargs)
+        self.k8s_config = KubeConfig()
+        try:
+            self.k8s_config.load_kube_config()
+        except kubernetes.config.ConfigException as e:
+            logger.error(f"Failed to load kubernetes config: {e}")
+            raise
+        self.apps_v1_api = client.AppsV1Api()
+        self.core_v1_api = client.CoreV1Api()
+        self.custom_api = client.CustomObjectsApi()
+        self.namespace = namespace
+
+    async def poke(self, release_name: str, cleanup_data_service: bool, cluster: str) -> bool:
+        """poke will delete the graph engine resources based on the user's configuration
+        1. This has to be done in the control plane by design. We don't expect any users's running pod to be authn/z to manage resources
+        2. This can not be done in the async agent because the delete callback is only invoked on abortion operation or failure phase.
+           while this makes sense but what we need is a separate task to delete graph engine without complicating the regular async agent flow.
+        3. In the near future, we will add the poking logic on the training job's status. In the initial implementation, we skipped
+        it for simplicity. This is also why we use the sensor API to keep forward compatibility
+        """
+        self.release_name = release_name
+        self.cleanup_data_service = cleanup_data_service
+        self.cluster = cluster
+        return await self._handle_cleanup()
+
+    async def _handle_cleanup(self) -> bool:
+        if not self.cleanup_data_service:
+            logger.info(
+                f"User decides to not to clean up the graph engine: {self.release_name} in cluster {self.cluster}, namespace {self.namespace}"
+            )
+            logger.info("DataService sensor will stop polling")
+            return True
+        logger.info(f"The training job is in terminal stage, deleting graph engine {self.release_name}")
+        self.delete_data_service()
+        return True
+
+    def delete_data_service(self):
+        """
+        Delete the data service's associated Kubernetes resources (StatefulSet and Service).
+        """
+
+        def delete_resource(resource_type: str, delete_fn):
+            try:
+                delete_fn(name=self.release_name, namespace=self.namespace, body=client.V1DeleteOptions())
+                logger.info(f"Deleted {resource_type}: {self.release_name}")
+            except ApiException as e:
+                logger.error(f"Error deleting {resource_type}: {e}")
+
+        logger.info(f"Sensor got the release name: {self.release_name}")
+        delete_resource("Service", self.core_v1_api.delete_namespaced_service)
+        delete_resource("StatefulSet", self.apps_v1_api.delete_namespaced_stateful_set)

flytekitplugins_k8sdataservice-1.15.0/flytekitplugins/k8sdataservice/task.py

@@ -0,0 +1,71 @@
+from dataclasses import asdict, dataclass
+from typing import Any, Dict, List, Optional, Type
+
+from google.protobuf import json_format
+from google.protobuf.struct_pb2 import Struct
+
+from flytekit import Resources, kwtypes, logger
+from flytekit.configuration import SerializationSettings
+from flytekit.core.base_task import PythonTask
+from flytekit.core.interface import Interface
+from flytekit.extend.backend.base_agent import AsyncAgentExecutorMixin
+
+
+@dataclass
+class DataServiceConfig(object):
+    """DataServiceConfig should be used to configure a DataServiceTask."""
+
+    Name: Optional[str] = None
+    Requests: Optional[Resources] = None
+    Limits: Optional[Resources] = None
+    Port: Optional[int] = None
+    Image: Optional[str] = None
+    Command: Optional[List[str]] = None
+    Replicas: Optional[int] = None
+    ExistingReleaseName: Optional[str] = None
+    Cluster: Optional[str] = None
+
+
+class DataServiceTask(AsyncAgentExecutorMixin, PythonTask[DataServiceConfig]):
+    _TASK_TYPE = "dataservicetask"
+
+    def __init__(
+        self,
+        name: str,
+        task_config: Optional[DataServiceConfig],
+        inputs: Optional[Dict[str, Type]] = None,
+        **kwargs,
+    ):
+        super().__init__(
+            name=name,
+            task_config=task_config,
+            interface=Interface(inputs=inputs, outputs=kwtypes(name=str)),
+            task_type=self._TASK_TYPE,
+            **kwargs,
+        )
+
+    def get_custom(self, settings: SerializationSettings) -> Dict[str, Any]:
+        logger.info("get_custom is invoked")
+        config = {}
+        limits = None
+        requests = None
+        if self.task_config is not None:
+            limits = asdict(self.task_config.Limits) if self.task_config.Limits is not None else None
+            requests = asdict(self.task_config.Requests) if self.task_config.Requests is not None else None
+            ge = {
+                "Name": self.task_config.Name,
+                "Image": self.task_config.Image,
+                "Command": self.task_config.Command,
+                "Port": self.task_config.Port,
+                "Replicas": self.task_config.Replicas,
+                "ExistingReleaseName": self.task_config.ExistingReleaseName,
+                "Cluster": self.task_config.Cluster,
+            }
+            if limits is not None:
+                ge["Limits"] = limits
+            if requests is not None:
+                ge["Requests"] = requests
+            config = ge
+        s = Struct()
+        s.update(config)
+        return json_format.MessageToDict(s)

flytekitplugins_k8sdataservice-1.15.0/flytekitplugins_k8sdataservice.egg-info/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.2
+Name: flytekitplugins-k8sdataservice
+Version: 1.15.0
+Summary: Flytekit K8s Data Service Plugin
+Author: LinkedIn
+Author-email: shuliang@linkedin.com
+License: apache2
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Requires-Dist: flytekit<2.0.0,>=1.11.0
+Requires-Dist: kubernetes<24.0.0,>=23.6.0
+Requires-Dist: flyteidl<2.0.0,>=1.11.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary