chore: import upstream snapshot with attribution

python/ray/serve/tests/test_config_files/test_dag/basic_dag.py

@@ -0,0 +1,28 @@
+from ray import serve
+from ray.serve.handle import DeploymentHandle
+
+
+@serve.deployment(
+    ray_actor_options={
+        "num_cpus": 0.1,
+    }
+)
+def f(*args):
+    return "wonderful world"
+
+
+@serve.deployment(
+    ray_actor_options={
+        "num_cpus": 0.1,
+    }
+)
+class BasicDriver:
+    def __init__(self, h: DeploymentHandle):
+        self._h = h
+
+    async def __call__(self):
+        return await self._h.remote()
+
+
+FNode = f.bind()
+DagNode = BasicDriver.bind(FNode)

python/ray/serve/tests/test_config_files/test_dag/conditional_dag.py

@@ -0,0 +1,97 @@
+import os
+from enum import Enum
+from typing import Dict
+
+import starlette.requests
+
+from ray import serve
+from ray.serve.handle import DeploymentHandle
+
+
+class Operation(str, Enum):
+    ADDITION = "ADD"
+    MULTIPLICATION = "MUL"
+
+
+@serve.deployment(
+    ray_actor_options={
+        "num_cpus": 0.1,
+    }
+)
+class Router:
+    def __init__(self, multiplier: DeploymentHandle, adder: DeploymentHandle):
+        self.adder = adder
+        self.multiplier = multiplier
+
+    async def route(self, op: Operation, input: int) -> int:
+        if op == Operation.ADDITION:
+            amount = await self.adder.add.remote(input)
+        elif op == Operation.MULTIPLICATION:
+            amount = await self.multiplier.multiply.remote(input)
+
+        return f"{amount} pizzas please!"
+
+    async def __call__(self, request: starlette.requests.Request) -> str:
+        op, input = await request.json()
+        return await self.route(op, input)
+
+
+@serve.deployment(
+    user_config={
+        "factor": 3,
+    },
+    ray_actor_options={
+        "num_cpus": 0.1,
+        "runtime_env": {
+            "env_vars": {
+                "override_factor": "-2",
+            }
+        },
+    },
+)
+class Multiplier:
+    def __init__(self, factor: int):
+        self.factor = factor
+
+    def reconfigure(self, config: Dict):
+        self.factor = config.get("factor", -1)
+
+    def multiply(self, input_factor: int) -> int:
+        if os.getenv("override_factor") is not None:
+            return input_factor * int(os.getenv("override_factor"))
+        return input_factor * self.factor
+
+
+@serve.deployment(
+    user_config={
+        "increment": 2,
+    },
+    ray_actor_options={
+        "num_cpus": 0.1,
+        "runtime_env": {
+            "env_vars": {
+                "override_increment": "-2",
+            }
+        },
+    },
+)
+class Adder:
+    def __init__(self, increment: int):
+        self.increment = increment
+
+    def reconfigure(self, config: Dict):
+        self.increment = config.get("increment", -1)
+
+    def add(self, input: int) -> int:
+        if os.getenv("override_increment") is not None:
+            return input + int(os.getenv("override_increment"))
+        return input + self.increment
+
+
+# Overwritten by user_config
+ORIGINAL_INCREMENT = 1
+ORIGINAL_FACTOR = 1
+
+multiplier = Multiplier.bind(ORIGINAL_FACTOR)
+adder = Adder.bind(ORIGINAL_INCREMENT)
+serve_dag = Router.bind(multiplier, adder)

python/ray/serve/tests/test_config_files/test_dag/dir/subdir/a/add_and_sub.py

@@ -0,0 +1,65 @@
+from enum import Enum
+
+import starlette.requests
+
+from ray import serve
+from ray.serve.handle import DeploymentHandle
+
+
+class Operation(str, Enum):
+    ADD = "ADD"
+    SUBTRACT = "SUB"
+
+
+@serve.deployment(
+    ray_actor_options={
+        "num_cpus": 0.1,
+    }
+)
+class Add:
+    # Requires the test_dag repo as a py_module:
+    # https://github.com/ray-project/test_dag
+
+    def add(self, input: int) -> int:
+        from dir2.library import add_one
+
+        return add_one(input)
+
+
+@serve.deployment(
+    ray_actor_options={
+        "num_cpus": 0.1,
+    }
+)
+class Subtract:
+    # Requires the test_module repo as a py_module:
+    # https://github.com/ray-project/test_module
+
+    def subtract(self, input: int) -> int:
+        from test_module.test import one
+
+        return input - one()  # Returns input - 2
+
+
+@serve.deployment(
+    ray_actor_options={
+        "num_cpus": 0.1,
+    }
+)
+class Router:
+    def __init__(self, adder: DeploymentHandle, subtractor: DeploymentHandle):
+        self.adder = adder
+        self.subtractor = subtractor
+
+    async def __call__(self, request: starlette.requests.Request) -> int:
+        op, input = await request.json()
+
+        if op == Operation.ADD:
+            return await self.adder.add.remote(input)
+        elif op == Operation.SUBTRACT:
+            return await self.subtractor.subtract.remote(input)
+
+
+adder = Add.bind()
+subtractor = Subtract.bind()
+serve_dag = Router.bind(adder, subtractor)

python/ray/serve/tests/test_config_files/test_dag/dir2/library.py

@@ -0,0 +1,2 @@
+def add_one(inp):
+    return inp + 1

python/ray/serve/tests/test_config_files/test_dag/hello_serve.py

@@ -0,0 +1,13 @@
+from starlette.requests import Request
+
+from ray import serve
+from ray.serve.tests.test_config_files.test_dag.utils.test import hello
+
+
+@serve.deployment
+class HelloModel:
+    async def __call__(self, starlette_request: Request) -> None:
+        return hello()
+
+
+model = HelloModel.bind()

python/ray/serve/tests/test_config_files/test_dag/utils/test.py

@@ -0,0 +1,2 @@
+def hello():
+    return "hello_from_utils"