Merge branch 'develop' into add_ut_requirement

Author: XieYunshen

.github/workflows/_pre_ce_test.yml

@@ -21,14 +21,19 @@ on:
         required: false
         type: string
         default: ""
+      MODEL_CACHE_DIR:
+        description: "Cache Dir Use"
+        required: false
+        type: string
+        default: ""
 
 concurrency:
   group: ${{ github.event.pull_request.number }}
   cancel-in-progress: true
 
 jobs:
   run_ce_cases:
-    runs-on: [self-hosted, GPU-L20-4Card]
+    runs-on: [self-hosted, PRE_CE_RUN_2Card]
     steps:
       - name: Print current runner name
         run: |
@@ -67,37 +72,51 @@ jobs:
         env:
           docker_image: ${{ inputs.DOCKER_IMAGE }}
           fd_wheel_url: ${{ inputs.FASTDEPLOY_WHEEL_URL }}
+          CACHE_DIR: ${{ inputs.CACHE_DIR }}
+          MODEL_CACHE_DIR: ${{ inputs.MODEL_CACHE_DIR }}
         run: |
           runner_name="${{ runner.name }}"
-          last_char="${runner_name: -1}"
+          CARD_ID=$(echo "${runner_name}" | awk -F'-' '{print $NF}')
+          DEVICES=$(echo "$CARD_ID" | fold -w1 | paste -sd,)
+          DEVICE_PORT=$(echo "$DEVICES" | cut -d',' -f1)
+
+          FLASK_PORT=$((42068 + DEVICE_PORT * 100))
+          FD_API_PORT=$((42088 + DEVICE_PORT * 100))
+          FD_ENGINE_QUEUE_PORT=$((42058 + DEVICE_PORT * 100))
+          FD_METRICS_PORT=$((42078 + DEVICE_PORT * 100))
+          echo "Test ENV Parameter:"
+          echo "========================================================="
+          echo "FLASK_PORT=${FLASK_PORT}"
+          echo "FD_API_PORT=${FD_API_PORT}"
+          echo "FD_ENGINE_QUEUE_PORT=${FD_ENGINE_QUEUE_PORT}"
+          echo "FD_METRICS_PORT=${FD_METRICS_PORT}"
+          echo "DEVICES=${DEVICES}"
+          echo "========================================================="
 
-          if [ "${last_char}" = "1" ]; then
-            gpu_id=2
-            DEVICES="2,3"
-          else
-            gpu_id=0
-            DEVICES="0,1"
+          CACHE_DIR="${CACHE_DIR:-$(dirname "$(dirname "${{ github.workspace }}")")}"
+          echo "CACHE_DIR is set to ${CACHE_DIR}"
+          if [ ! -f "${CACHE_DIR}/gitconfig" ]; then
+            touch "${CACHE_DIR}/gitconfig"
           fi
-          FD_API_PORT=$((9180 + gpu_id * 100))
-          FD_ENGINE_QUEUE_PORT=$((9150 + gpu_id * 100))
-          FD_METRICS_PORT=$((9170 + gpu_id * 100))
 
-          PARENT_DIR=$(dirname "$WORKSPACE")
-          echo "PARENT_DIR:$PARENT_DIR"
           docker run --rm --net=host -v $(pwd):/workspace -w /workspace \
-          -v "/ssd4/GithubActions/gitconfig:/etc/gitconfig:ro" \
-          -v "/ssd4/GithubActions/ModelData:/ModelData:ro" \
-          -v "/ssd4/GithubActions/CacheDir:/root/.cache" \
-          -v "/ssd4/GithubActions/ConfigDir:/root/.config" \
+          -v "${CACHE_DIR}/gitconfig:/etc/gitconfig:ro" \
+          -v "${CACHE_DIR}/.cache:/root/.cache" \
+          -v "${CACHE_DIR}/ConfigDir:/root/.config" \
+          -v "${MODEL_CACHE_DIR}:/ModelData:ro" \
           -e "MODEL_PATH=/ModelData" \
           -e "FD_API_PORT=${FD_API_PORT}" \
           -e "FD_ENGINE_QUEUE_PORT=${FD_ENGINE_QUEUE_PORT}" \
           -e "FD_METRICS_PORT=${FD_METRICS_PORT}" \
+          -e "FLASK_PORT=${FLASK_PORT}" \
           -e "fd_wheel_url=${fd_wheel_url}" \
-          --gpus '"device='"${DEVICES}"'"' ${docker_image} /bin/bash -c '
+          --gpus "\"device=${DEVICES}\"" ${docker_image} /bin/bash -c '
           git config --global --add safe.directory /workspace/FastDeploy
           cd FastDeploy
           python -m pip install --pre paddlepaddle-gpu -i https://www.paddlepaddle.org.cn/packages/nightly/cu126/
           python -m pip install ${fd_wheel_url}
+          for port in $FLASK_PORT $FD_API_PORT $FD_ENGINE_QUEUE_PORT $FD_METRICS_PORT; do
+            lsof -t -i :$port | xargs -r kill -9 || true
+          done
           bash scripts/run_pre_ce.sh
           '

.github/workflows/_unit_test_coverage.yml

@@ -22,6 +22,11 @@ on:
         required: false
         type: string
         default: ""
+      MODEL_CACHE_DIR:
+        description: "Cache Dir Use"
+        required: false
+        type: string
+        default: ""
 
 jobs:
   run_tests_with_coverage:
@@ -67,11 +72,26 @@ jobs:
           fd_wheel_url: ${{ inputs.FASTDEPLOY_WHEEL_URL }}
           CACHE_DIR: ${{ inputs.CACHE_DIR }}
           BASE_REF: ${{ github.event.pull_request.base.ref }}
+          MODEL_CACHE_DIR: ${{ inputs.MODEL_CACHE_DIR }}
         run: |
             set -x
             runner_name="${{ runner.name }}"
             CARD_ID=$(echo "${runner_name}" | awk -F'-' '{print $NF}')
-            gpu_id=$(echo "$CARD_ID" | fold -w1 | paste -sd,)
+            DEVICES=$(echo "$CARD_ID" | fold -w1 | paste -sd,)
+            DEVICE_PORT=$(echo "$DEVICES" | cut -d',' -f1)
+
+            FLASK_PORT=$((42068 + DEVICE_PORT * 100))
+            FD_API_PORT=$((42088 + DEVICE_PORT * 100))
+            FD_ENGINE_QUEUE_PORT=$((42058 + DEVICE_PORT * 100))
+            FD_METRICS_PORT=$((42078 + DEVICE_PORT * 100))
+            echo "Test ENV Parameter:"
+            echo "========================================================="
+            echo "FLASK_PORT=${FLASK_PORT}"
+            echo "FD_API_PORT=${FD_API_PORT}"
+            echo "FD_ENGINE_QUEUE_PORT=${FD_ENGINE_QUEUE_PORT}"
+            echo "FD_METRICS_PORT=${FD_METRICS_PORT}"
+            echo "DEVICES=${DEVICES}"
+            echo "========================================================="
 
             CACHE_DIR="${CACHE_DIR:-$(dirname "$(dirname "${{ github.workspace }}")")}"
             echo "CACHE_DIR is set to ${CACHE_DIR}"
@@ -86,15 +106,21 @@ jobs:
             -v "${CACHE_DIR}/gitconfig:/etc/gitconfig:ro" \
             -v "${CACHE_DIR}/.cache:/root/.cache" \
             -v "${CACHE_DIR}/ConfigDir:/root/.config" \
+            -v "${MODEL_CACHE_DIR}:/ModelData:ro" \
+            -e "MODEL_PATH=/ModelData" \
+            -e "FD_API_PORT=${FD_API_PORT}" \
+            -e "FD_ENGINE_QUEUE_PORT=${FD_ENGINE_QUEUE_PORT}" \
+            -e "FD_METRICS_PORT=${FD_METRICS_PORT}" \
+            -e "FLASK_PORT=${FLASK_PORT}" \
             -e TZ="Asia/Shanghai" \
             -e "fd_wheel_url=${fd_wheel_url}" \
             -e "BASE_REF=${BASE_REF}" \
-            --gpus "\"device=${gpu_id}\"" ${docker_image} /bin/bash -c '
+            --gpus "\"device=${DEVICES}\"" ${docker_image} /bin/bash -c '
 
             git config --global --add safe.directory /workspace/FastDeploy
             cd FastDeploy
             python -m pip install --pre paddlepaddle-gpu -i https://www.paddlepaddle.org.cn/packages/nightly/cu126/
-
+            
             pip config set global.index-url https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple
             python -m pip install -r scripts/unittest_requirement.txt
 
@@ -157,7 +183,7 @@ jobs:
             echo "unittest_failed_url=${UNIT_TEST_RESULT_URL}" >> $GITHUB_OUTPUT
             echo "unittest_failed_url=${UNIT_TEST_RESULT_URL}" >> $GITHUB_ENV
           fi
-      - name: Determine Unit Succ and whether the coverage rate reaches 80%
+      - name: Check Unit Test Success
         shell: bash
         run: |
           if [ "$TEST_EXIT_CODE" -eq 8 ]; then
@@ -175,7 +201,11 @@ jobs:
             fi
             exit "$TEST_EXIT_CODE"
           fi
+          echo "All tests passed"
 
+      - name: Verify Code Coverage Threshold (80%)
+        shell: bash
+        run: |
           if [ "$COVERAGE_EXIT_CODE" -eq 9 ]; then
             echo "Coverage generation failed (exit code 9)"
             filename=$(basename "$diff_cov_result_json_url")
@@ -195,7 +225,7 @@ jobs:
             fi
             exit "$COVERAGE_EXIT_CODE"
           fi
-          echo "All tests and coverage passed"
+          echo "coverage passed"
           exit 0
 
   diff_coverage_report:

.github/workflows/pr_build_and_test.yml

@@ -42,6 +42,7 @@ jobs:
       DOCKER_IMAGE: ccr-2vdh3abv-pub.cnc.bj.baidubce.com/paddlepaddle/paddleqa:fastdeploy-ciuse-cuda126-dailyupdate
       FASTDEPLOY_ARCHIVE_URL: ${{ needs.clone.outputs.repo_archive_url }}
       FASTDEPLOY_WHEEL_URL: ${{ needs.build.outputs.wheel_path }}
+      MODEL_CACHE_DIR: "/ssd2/actions-runner/ModelData"
 
   logprob_test:
     name: Run FastDeploy LogProb Tests
@@ -51,16 +52,17 @@ jobs:
       DOCKER_IMAGE: ccr-2vdh3abv-pub.cnc.bj.baidubce.com/paddlepaddle/paddleqa:fastdeploy-ciuse-cuda126-dailyupdate
       PADDLETEST_ARCHIVE_URL: "https://xly-devops.bj.bcebos.com/PaddleTest/PaddleTest.tar.gz"
       FASTDEPLOY_WHEEL_URL: ${{ needs.build.outputs.wheel_path }}
-      MODEL_CACHE_DIR: "/ssd2/actions-runner/ModelCache"
+      MODEL_CACHE_DIR: "/ssd2/actions-runner/ModelData"
 
   pre_ce_test:
     name: Extracted partial CE model tasks to run in CI.
     needs: [clone,build]
     uses: ./.github/workflows/_pre_ce_test.yml
     with:
-      DOCKER_IMAGE: ccr-2vdh3abv-pub.cnc.bj.baidubce.com/paddlepaddle/paddle:fastdeploy-ciuse-cuda126
+      DOCKER_IMAGE: ccr-2vdh3abv-pub.cnc.bj.baidubce.com/paddlepaddle/paddleqa:fastdeploy-ciuse-cuda126-dailyupdate
       FASTDEPLOY_ARCHIVE_URL: ${{ needs.clone.outputs.repo_archive_url }}
       FASTDEPLOY_WHEEL_URL: ${{ needs.build.outputs.wheel_path }}
+      MODEL_CACHE_DIR: "/ssd2/actions-runner/ModelData"
 
   base_test:
     name: Run Base Tests
@@ -70,4 +72,4 @@ jobs:
       DOCKER_IMAGE: ccr-2vdh3abv-pub.cnc.bj.baidubce.com/paddlepaddle/paddleqa:fastdeploy-ciuse-cuda126-dailyupdate
       FASTDEPLOY_ARCHIVE_URL: ${{ needs.clone.outputs.repo_archive_url }}
       FASTDEPLOY_WHEEL_URL: ${{ needs.build.outputs.wheel_path }}
-      MODEL_CACHE_DIR: "/ssd2/actions-runner/ModelCache"
+      MODEL_CACHE_DIR: "/ssd2/actions-runner/ModelData"

fastdeploy/entrypoints/openai/serving_completion.py

@@ -234,6 +234,15 @@ async def completion_full_generator(
             if dealer is not None:
                 dealer.close()
 
+    def calc_finish_reason(self, max_tokens, token_num, output):
+        if max_tokens is None or token_num != max_tokens:
+            if self.engine_client.reasoning_parser == "ernie_x1" and output.get("finish_reason", "") == "tool_calls":
+                return "tool_calls"
+            else:
+                return "stop"
+        else:
+            return "length"
+
     async def completion_stream_generator(
         self,
         request: CompletionRequest,
@@ -334,19 +343,13 @@ async def completion_stream_generator(
                             logprobs=logprobs_res,
                         )
                     )
-                    if res["finished"]:
-                        if request.max_tokens is None or output_tokens[idx] + 1 != request.max_tokens:
-                            chunk.choices[0].finish_reason = "stop"
-                            if (
-                                self.engine_client.reasoning_parser == "ernie_x1"
-                                and output.get("finish_reason", "") == "tool_calls"
-                            ):
-                                chunk.choices[0].finish_reason = "tool_calls"
-                        else:
-                            chunk.choices[0].finish_reason = "length"
-
                     output_tokens[idx] += 1
 
+                    if res["finished"]:
+                        choices[-1].finish_reason = self.calc_finish_reason(
+                            request.max_tokens, output_tokens[idx], output
+                        )
+
                     if len(choices) == max_streaming_response_tokens or res["finished"]:
                         chunk = CompletionStreamResponse(
                             id=request_id,
@@ -433,6 +436,8 @@ def request_output_to_completion_response(
                 token_ids = output["token_ids"]
                 output_text = output["text"]
 
+            finish_reason = self.calc_finish_reason(request.max_tokens, final_res["output_token_ids"], output)
+
             choice_data = CompletionResponseChoice(
                 token_ids=token_ids,
                 index=len(choices),
@@ -442,7 +447,7 @@ def request_output_to_completion_response(
                 reasoning_content=output.get("reasoning_content"),
                 tool_calls=output.get("tool_call_content"),
                 logprobs=aggregated_logprobs,
-                finish_reason=None,
+                finish_reason=finish_reason,
             )
             choices.append(choice_data)
 

test/entrypoints/openai/test_serving_completion.py

@@ -0,0 +1,111 @@
+import unittest
+from typing import List
+from unittest.mock import Mock
+
+from fastdeploy.entrypoints.openai.serving_completion import (
+    CompletionRequest,
+    OpenAIServingCompletion,
+    RequestOutput,
+)
+
+
+class TestOpenAIServingCompletion(unittest.TestCase):
+
+    def test_calc_finish_reason_tool_calls(self):
+        # 创建一个模拟的engine_client，并设置reasoning_parser为"ernie_x1"
+        engine_client = Mock()
+        engine_client.reasoning_parser = "ernie_x1"
+        # 创建一个OpenAIServingCompletion实例
+        serving_completion = OpenAIServingCompletion(engine_client, "pid", "ips", 360)
+        # 创建一个模拟的output，并设置finish_reason为"tool_calls"
+        output = {"finish_reason": "tool_calls"}
+        # 调用calc_finish_reason方法
+        result = serving_completion.calc_finish_reason(None, 100, output)
+        # 断言结果为"tool_calls"
+        assert result == "tool_calls"
+
+    def test_calc_finish_reason_stop(self):
+        # 创建一个模拟的engine_client，并设置reasoning_parser为"ernie_x1"
+        engine_client = Mock()
+        engine_client.reasoning_parser = "ernie_x1"
+        # 创建一个OpenAIServingCompletion实例
+        serving_completion = OpenAIServingCompletion(engine_client, "pid", "ips", 360)
+        # 创建一个模拟的output，并设置finish_reason为其他值
+        output = {"finish_reason": "other_reason"}
+        # 调用calc_finish_reason方法
+        result = serving_completion.calc_finish_reason(None, 100, output)
+        # 断言结果为"stop"
+        assert result == "stop"
+
+    def test_calc_finish_reason_length(self):
+        # 创建一个模拟的engine_client
+        engine_client = Mock()
+        # 创建一个OpenAIServingCompletion实例
+        serving_completion = OpenAIServingCompletion(engine_client, "pid", "ips", 360)
+        # 创建一个模拟的output
+        output = {}
+        # 调用calc_finish_reason方法
+        result = serving_completion.calc_finish_reason(100, 100, output)
+        # 断言结果为"length"
+        assert result == "length"
+
+    def test_request_output_to_completion_response(self):
+        engine_client = Mock()
+        # 创建一个OpenAIServingCompletion实例
+        openai_serving_completion = OpenAIServingCompletion(engine_client, "pid", "ips", 360)
+        final_res_batch: List[RequestOutput] = [
+            {
+                "prompt": "Hello, world!",
+                "outputs": {
+                    "token_ids": [1, 2, 3],
+                    "text": " world!",
+                    "top_logprobs": {
+                        "a": 0.1,
+                        "b": 0.2,
+                    },
+                },
+                "output_token_ids": 3,
+            },
+            {
+                "prompt": "Hello, world!",
+                "outputs": {
+                    "token_ids": [4, 5, 6],
+                    "text": " world!",
+                    "top_logprobs": {
+                        "a": 0.3,
+                        "b": 0.4,
+                    },
+                },
+                "output_token_ids": 3,
+            },
+        ]
+
+        request: CompletionRequest = Mock()
+        request_id = "test_request_id"
+        created_time = 1655136000
+        model_name = "test_model"
+        prompt_batched_token_ids = [[1, 2, 3], [4, 5, 6]]
+        completion_batched_token_ids = [[7, 8, 9], [10, 11, 12]]
+
+        completion_response = openai_serving_completion.request_output_to_completion_response(
+            final_res_batch=final_res_batch,
+            request=request,
+            request_id=request_id,
+            created_time=created_time,
+            model_name=model_name,
+            prompt_batched_token_ids=prompt_batched_token_ids,
+            completion_batched_token_ids=completion_batched_token_ids,
+        )
+
+        assert completion_response.id == request_id
+        assert completion_response.created == created_time
+        assert completion_response.model == model_name
+        assert len(completion_response.choices) == 2
+
+        # 验证 choices 的 text 属性
+        assert completion_response.choices[0].text == "Hello, world! world!"
+        assert completion_response.choices[1].text == "Hello, world! world!"
+
+
+if __name__ == "__main__":
+    unittest.main()