♻️ refactor me model module.

Author: jiangpeiling

.github/workflows/auto-unit-test.yml

@@ -17,12 +17,14 @@ on:
       - 'backend/**'
       - 'sdk/**'
       - 'test/**'
+      - '.github/workflows/**'
   push:
     branches: [develop]
     paths:
       - 'backend/**'
       - 'sdk/**'
       - 'test/**'
+      - '.github/workflows/**'
 
 jobs:
   test:

backend/apps/me_model_managment_app.py

@@ -1,118 +1,52 @@
-import asyncio
+from http import HTTPStatus
 
-import aiohttp
 from fastapi import APIRouter, Query
+from fastapi.responses import JSONResponse
 
-from consts.const import MODEL_ENGINE_APIKEY, MODEL_ENGINE_HOST
-from consts.model import ModelConnectStatusEnum, ModelResponse
-from services.model_health_service import check_me_model_connectivity
+from consts.model import ModelResponse
+from services.me_model_management_service import get_me_models_impl
+from services.model_health_service import check_me_model_connectivity, check_me_connectivity_impl
 
 router = APIRouter(prefix="/me")
 
 
-@router.get("/model/list", response_model=ModelResponse)
+@router.get("/model/list")
 async def get_me_models(
         type: str = Query(
             default="", description="Model type: embed/chat/rerank"),
         timeout: int = Query(
             default=2, description="Request timeout in seconds")
 ):
-    try:
-        headers = {
-            'Authorization': f'Bearer {MODEL_ENGINE_APIKEY}',
+    """
+    Get list of models from model engine API
+    """
+    # Call service function to get business logic result
+    code, message, data = await get_me_models_impl(timeout=timeout, type=type)
+    return JSONResponse(
+        status_code=HTTPStatus.OK,
+        content={
+            "code": code,
+            "message": message,
+            "data": data
         }
+    )
 
-        async with aiohttp.ClientSession(
-            timeout=aiohttp.ClientTimeout(total=timeout),
-            connector=aiohttp.TCPConnector(verify_ssl=False)
-        ) as session:
-            async with session.get(
-                f"{MODEL_ENGINE_HOST}/open/router/v1/models",
-                headers=headers
-            ) as response:
-                response.raise_for_status()
-                result_data = await response.json()
-                result: list = result_data['data']
 
-        # Type filtering
-        filtered_result = []
-        if type:
-            for data in result:
-                if data['type'] == type:
-                    filtered_result.append(data)
-            if not filtered_result:
-                result_types = set(data['type'] for data in result)
-                return ModelResponse(
-                    code=404,
-                    message=f"No models found with type '{type}'. Available types: {result_types}",
-                    data=[]
-                )
-        else:
-            filtered_result = result
-
-        return ModelResponse(
-            code=200,
-            message="Successfully retrieved",
-            data=filtered_result
-        )
-
-    except asyncio.TimeoutError:
-        return ModelResponse(
-            code=408,
-            message="Request timeout",
-            data=[]
-        )
-    except Exception as e:
-        return ModelResponse(
-            code=500,
-            message=f"Failed to get model list: {str(e)}",
-            data=[]
-        )
-
-
-@router.get("/healthcheck", response_model=ModelResponse)
+@router.get("/healthcheck")
 async def check_me_connectivity(timeout: int = Query(default=2, description="Timeout in seconds")):
-    try:
-        headers = {'Authorization': f'Bearer {MODEL_ENGINE_APIKEY}'}
-
-        async with aiohttp.ClientSession(
-            timeout=aiohttp.ClientTimeout(total=timeout),
-            connector=aiohttp.TCPConnector(ssl=False)
-        ) as session:
-            try:
-                async with session.get(
-                    f"{MODEL_ENGINE_HOST}/open/router/v1/models",
-                    headers=headers
-                ) as response:
-                    if response.status == 200:
-                        return ModelResponse(
-                            code=200,
-                            message="Connection successful",
-                            data={"status": "Connected", "desc": "Connection successful",
-                                  "connect_status": ModelConnectStatusEnum.AVAILABLE.value}
-                        )
-                    else:
-                        return ModelResponse(
-                            code=response.status,
-                            message=f"Connection failed, error code: {response.status}",
-                            data={"status": "Disconnected", "desc": f"Connection failed, error code: {response.status}",
-                                  "connect_status": ModelConnectStatusEnum.UNAVAILABLE.value}
-                        )
-            except asyncio.TimeoutError:
-                return ModelResponse(
-                    code=408,
-                    message="Connection timeout",
-                    data={"status": "Disconnected", "desc": "Connection timeout",
-                          "connect_status": ModelConnectStatusEnum.UNAVAILABLE.value}
-                )
-
-    except Exception as e:
-        return ModelResponse(
-            code=500,
-            message=f"Unknown error occurred: {str(e)}",
-            data={"status": "Disconnected", "desc": f"Unknown error occurred: {str(e)}",
-                  "connect_status": ModelConnectStatusEnum.UNAVAILABLE.value}
-        )
+    """
+    Health check from model engine API
+    """
+    # Call service function to health check
+    code, message, data = await check_me_connectivity_impl(timeout)
+    return JSONResponse(
+        status_code=HTTPStatus.OK,
+        content={
+            "code": code,
+            "message": message,
+            "data": data
+        }
+    )
 
 
 @router.get("/model/healthcheck", response_model=ModelResponse)

backend/services/me_model_management_service.py

@@ -0,0 +1,54 @@
+import asyncio
+from http import HTTPStatus
+from typing import List, Dict
+
+import aiohttp
+
+from consts.const import MODEL_ENGINE_APIKEY, MODEL_ENGINE_HOST
+
+
+async def get_me_models_impl(timeout: int = 2, type: str = "") -> tuple[int, str, List[Dict]]:
+    """
+    Fetches a list of models from the model engine API with response formatting.
+    Parameters:
+        timeout (int): The total timeout for the request in seconds.
+        type (str): The type of model to filter for. If empty, returns all models.
+    Returns:
+        tuple: (code, message, data) where:
+            - code: HTTP status code
+            - message: Response message
+            - data: List of model data dictionaries
+    """
+    try:
+        headers = {
+            'Authorization': f'Bearer {MODEL_ENGINE_APIKEY}',
+        }
+        async with aiohttp.ClientSession(
+                timeout=aiohttp.ClientTimeout(total=timeout),
+                connector=aiohttp.TCPConnector(verify_ssl=False)
+        ) as session:
+            async with session.get(
+                    f"{MODEL_ENGINE_HOST}/open/router/v1/models",
+                    headers=headers
+            ) as response:
+                response.raise_for_status()
+                result_data = await response.json()
+                result: list = result_data['data']
+
+        # Type filtering
+        filtered_result = []
+        if type:
+            for data in result:
+                if data['type'] == type:
+                    filtered_result.append(data)
+            if not filtered_result:
+                result_types = set(data['type'] for data in result)
+                return HTTPStatus.NOT_FOUND, f"No models found with type '{type}'. Available types: {result_types}.", []
+        else:
+            filtered_result = result
+
+        return HTTPStatus.OK, "Successfully retrieved", filtered_result
+    except asyncio.TimeoutError:
+        return HTTPStatus.REQUEST_TIMEOUT, "Request timeout", []
+    except Exception as e:
+        return HTTPStatus.INTERNAL_SERVER_ERROR, f"Failed to get model list: {str(e)}", []