[update] add delete faas instance

Author: zirongluo

dashscope/finetune/agentic_rl.py

@@ -3,6 +3,7 @@
 
 # Copyright (c) Alibaba, Inc. and its affiliates.
 
+import time
 from typing import Union, List, Optional, ClassVar, Dict, Any
 from typing_extensions import Self
 
@@ -429,6 +430,8 @@ async def test_functions(
         api_key: str = None,
         pull_logs: bool = False,
         log_page_size: int = 100,
+        start_time: Optional[int] = None,
+        end_time: Optional[int] = None,
     ):
         """Test a deployed function instance with custom input data.
 
@@ -442,6 +445,10 @@ async def test_functions(
                 (with pagination) after verification and print them
                 between separator markers.
             log_page_size: Page size used when pulling logs.
+            start_time: Optional start time filter (in seconds) for log
+                pulling. Defaults to 24 hours before ``end_time``.
+            end_time: Optional end time filter (in seconds) for log
+                pulling. Defaults to the current time (now).
         """
         try:
             set_api_key(api_key)
@@ -475,6 +482,8 @@ async def test_functions(
                 await cls._pull_function_instance_logs(
                     function_instance_id=instance_id,
                     page_size=log_page_size,
+                    start_time=start_time,
+                    end_time=end_time,
                 )
 
             return result
@@ -579,14 +588,61 @@ async def query_all_function_instance_logs(
                 error_code=3010,
             ) from e
 
+    @classmethod
+    async def delete_function_instance(
+        cls,
+        function_instance_id: str,
+        api_key: str = None,
+    ) -> Dict[str, Any]:
+        """Delete a function (faas) runtime instance.
+
+        Args:
+            function_instance_id: Target function instance ID.
+            api_key: DashScope API key (uses DASHSCOPE_API_KEY env var
+                if omitted).
+
+        Returns:
+            Raw response dict of the delete API, containing
+            ``data.status`` (e.g. "deleted") and
+            ``data.sandbox_code``.
+
+        Raises:
+            InstanceQueryError: If the deletion fails.
+        """
+        try:
+            set_api_key(api_key)
+
+            fc_component = AgenticRLFunctionComponent
+            return await fc_component.delete_function_instance(
+                function_instance_id=function_instance_id,
+            )
+
+        except Exception as e:
+            if hasattr(e, "error_code"):
+                raise
+            raise InstanceQueryError(
+                "Function instance deletion failed",
+                error_code=3011,
+            ) from e
+
     @classmethod
     async def _pull_function_instance_logs(
         cls,
         function_instance_id: str,
         page_size: int = 100,
+        start_time: Optional[int] = None,
+        end_time: Optional[int] = None,
     ) -> None:
         """Pull all logs of a function instance and print them between
-        separator markers (best effort, never raises)."""
+        separator markers (best effort, never raises).
+
+        When ``start_time``/``end_time`` are not provided, defaults to
+        pulling logs from 24 hours ago until now.
+        """
+        if end_time is None:
+            end_time = int(time.time())
+        if start_time is None:
+            start_time = end_time - 24 * 60 * 60
         logger.info(
             "************start query log "
             f"(function_instance_id={function_instance_id})*******",
@@ -595,6 +651,8 @@ async def _pull_function_instance_logs(
             logs = await cls.query_all_function_instance_logs(
                 function_instance_id=function_instance_id,
                 page_size=page_size,
+                start_time=start_time,
+                end_time=end_time,
             )
             for entry in logs:
                 logger.info(f"[function instance log] {entry}")

dashscope/finetune/reinforcement/__init__.py

@@ -16,6 +16,7 @@
     DASHSCOPE_HTTP_BASE_URL,
     LOG_LEVEL,
     FC_API_KEY,
+    FC_DELETE_API,
     FC_FILES_START,
     FC_LOAD_API,
     FC_PYPI_LIB,
@@ -155,6 +156,7 @@ def __getattr__(name):
     "DASHSCOPE_HTTP_BASE_URL",
     "LOG_LEVEL",
     "FC_API_KEY",
+    "FC_DELETE_API",
     "FC_FILES_START",
     "FC_LOAD_API",
     "FC_PYPI_LIB",

dashscope/finetune/reinforcement/common/constants.py

@@ -87,6 +87,10 @@ def get_int_env(env_var: str, default: int) -> int:
     "FC_QUERY_LOG_API",
     f"{FC_BASE_ENDPOINT}/query/faas/log",
 )
+FC_DELETE_API = os.environ.get(
+    "FC_DELETE_API",
+    f"{FC_BASE_ENDPOINT}/delete/faas",
+)
 FC_LAYER_CREATE_API = os.environ.get(  # POST
     "FC_LAYER_CREATE_API",
     f"{FC_BASE_ENDPOINT}/create/faas/layer",

dashscope/finetune/reinforcement/common/model.py

@@ -25,6 +25,7 @@
 # Local Application
 from dashscope.finetune.reinforcement.common.constants import (
     FC_API_KEY,
+    FC_DELETE_API,
     FC_LOAD_API,
     FC_QUERY_API,
     FC_QUERY_LOG_API,
@@ -1063,12 +1064,26 @@ def _extract_log_page(
     ) -> Tuple[List[str], Optional[int]]:
         """Extract log messages and total count from a log query response.
 
-        Expected response format::
+        Two payload shapes are supported. The DashScope gateway returns
+        snake_case keys under "output"::
+
+            {
+              "request_id": "...",
+              "output": {
+                "page_number": 1,
+                "page_size": 100,
+                "total_count": 86,
+                "log_entries": [
+                  {"instance_id": "...", "message": "...",
+                   "timestamp": 1699051200}
+                ]
+              }
+            }
+
+        while the backend service returns camelCase keys under "data"::
 
             {
               "success": true,
-              "code": null,
-              "message": null,
               "data": {
                 "pageNumber": 1,
                 "pageSize": 50,
@@ -1083,17 +1098,21 @@ def _extract_log_page(
         Only the "message" field of each log entry is kept; other fields
         are ignored.
         """
-        data = result.get("data", {})
+        data = result.get("output")
+        if not isinstance(data, Dict):
+            data = result.get("data")
         if not isinstance(data, Dict):
             return [], None
 
-        entries = data.get("logEntries") or []
+        entries = data.get("log_entries") or data.get("logEntries") or []
         logs = [
             entry.get("message", "") if isinstance(entry, Dict) else str(entry)
             for entry in entries
         ]
 
-        total = data.get("totalCount")
+        total = data.get("total_count")
+        if total is None:
+            total = data.get("totalCount")
         if not isinstance(total, int):
             total = None
 
@@ -1216,6 +1235,62 @@ async def query_all_function_instance_logs(
         )
         return all_logs
 
+    @classmethod
+    async def delete_function_instance(
+        cls,
+        function_instance_id: str,
+    ) -> Dict[str, Any]:
+        """Delete a function (faas) runtime instance.
+
+        Args:
+            function_instance_id: Target function instance ID.
+
+        Returns:
+            Raw response dict of the delete API, e.g.::
+
+                {
+                  "code": 0,
+                  "message": "success",
+                  "data": {
+                    "status": "deleted",
+                    "sandbox_code": "sandbox-xxx"
+                  }
+                }
+        """
+        if not function_instance_id:
+            raise InputError(
+                "No function instance ID available for deletion",
+                error_code=2074,
+            )
+
+        url = f"{FC_DELETE_API}/{function_instance_id}"
+        result = await client_fc(FC_API_KEY, url, {})
+        status = result.get("status", {})
+        if isinstance(status, Dict) and status.get("code", 200) != 200:
+            raise InstanceQueryError(
+                f"Function instance deletion failed: {result}",
+                error_code=2075,
+                instance_id=function_instance_id,
+            )
+        code = result.get("code")
+        if result.get("success") is False or (
+            code is not None and code not in (0, 200)
+        ):
+            raise InstanceQueryError(
+                "Function instance deletion failed: "
+                f"{result.get('message') or result}",
+                error_code=2075,
+                instance_id=function_instance_id,
+            )
+
+        data = result.get("data", {})
+        status_value = data.get("status") if isinstance(data, Dict) else data
+        logger.info(
+            f"Function instance deleted | FunctionInstanceID: "
+            f"{function_instance_id} | Status: {status_value}",
+        )
+        return result
+
 
 class RolloutFunctionComponent(AgenticRLFunctionComponent):
     """Rollout function component with type fixed as ROLLOUT."""