update

app.py

@@ -4,14 +4,14 @@ from fastapi import FastAPI, Request, HTTPException, Depends, status
 from fastapi.responses import Response # 导入Response
 from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials # 导入HTTPBearer和HTTPAuthorizationCredentials
 import httpx # 使用httpx替代requests，因为requests是同步的，而FastAPI是异步的
-import os, json
+import os, json, pprint
 from dotenv import load_dotenv
 from enum import Enum
 from supabase import create_client, Client
+from datetime import datetime, timezone, time # 导入 datetime 和 timezone
 
 # 加载环境变量
 load_dotenv()
-print('000000000000-111111111-222222')
 
 # 从环境变量获取代理自身的API密钥
 proxy_api_key = os.getenv("PROXY_API_KEY")
@@ -55,102 +55,82 @@ async def health_check():
 @app.api_route("/v1/{protocol}/{host}/{path:path}", methods=["GET", "POST", "PUT", "DELETE"])
 # @app.api_route("/v1/{protocol}/{host}/{path:path}", methods=["POST"])
 async def proxy(request: Request, protocol: ProtocolType, host:str, path: str, proxy_api_key: str = Depends(verify_proxy_api_key)): # 添加代理认证依赖
-
-    print('\n\n======================================')
-
-    real_url = f"{protocol.value}://{host}/{path}"
-    
-    # 提取客户端请求的headers和body，透传给Gemini
-    client_headers = dict(request.headers)
-    
-    # 移除FastAPI自带的Host头，避免Gemini校验报错
-    client_headers.pop("host", None)
-    client_headers.pop("authorization", None)
-    client_headers.pop("user-agent", None)
-    client_headers.pop("content-length", None)
-    
-    # 将User-Agent改为curl/8.7.1，以模拟curl请求
-    client_headers["User-Agent"] = "curl/8.7.1"
+    send_req = await make_send_req(request, protocol, host, path)
+
+    # 使用httpx异步客户端发起请求
+    async with httpx.AsyncClient() as client:
+        response = await client.request(
+            method=send_req.get('method'),
+            url=send_req.get('url'),
+            headers=send_req.get('headers'),
+            content=send_req.get('content'), # httpx使用content参数传递请求体
+            timeout=30  # 超时时间，可调整
+        )
 
     try:
-        # 读取客户端请求体
-        client_body = await request.body()
-        # print('client_body', client_body)
-        
-        # 尝试从请求体中获取model
-        model_from_body = None
-        try:
-            if client_body:
-                body_json = json.loads(client_body)
-                # print('body_json', body_json)
-                model_from_body = body_json.get("model")
-                # print('model_from_body', model_from_body)
-        except json.JSONDecodeError:
-            # 如果请求体不是JSON，则忽略
-            pass
-
-        print('model', model_from_body)
-
-        # 获取 api_key
-        api_key = await get_api_key(model_from_body if model_from_body else 'glm-4-flash')
-        api_key_show = api_key[:5] + '...' + api_key[-5:]
-        print('api_key', api_key_show)
-        if not api_key:
-            raise HTTPException(status_code=500, detail="没有可用的API密钥！")
-
-        # 使用httpx异步客户端发起请求
-        async with httpx.AsyncClient() as client:
-            client_headers["Authorization"] = f"Bearer {api_key}"
-            response = await client.request(
-                method=request.method,
-                url=real_url,
-                headers=client_headers,
-                content=client_body, # httpx使用content参数传递请求体
-                timeout=30  # 超时时间，可调整
-            )
-        
-        # 将Gemini的响应透传给客户端
-        return Response(
-            content=response.content,
-            status_code=response.status_code,
-            headers=dict(response.headers)
-        )
-    
-    except httpx.RequestError as e:
-        print('\n\n----------------- 1 ------------------')
-        print(str(e))
-        print('\n\n----------------- 2 ------------------')
-        # return 
-        # raise HTTPException(status_code=e.response.status_code, detail=f"转发请求失败：{str(e)}")
-        raise HTTPException(status_code=500, detail=f"转发请求失败：{str(e)}")
-    except httpx.HTTPStatusError as e:
-        print('\n\n----------------- 3 ------------------')
-        print(str(e))
-        print('\n\n----------------- 4 ------------------')
-        raise HTTPException(status_code=e.response.status_code, detail=f"目标API返回错误：{e.response.text}")
+        current_local_time = datetime.now().isoformat()
+        supabase.table("airs_api_keys").update({"ran_at": current_local_time}).eq("id", send_req.get('api_key_info').get('api_key_id')).execute()
+        print('更新成功')
     except Exception as e:
-        print('\n\n----------------- 5 ------------------')
-        print(str(e))
-        print('\n\n----------------- 6 ------------------')
-        # raise HTTPException(status_code=e.response.status_code, detail=f"转发失败：{str(e)}")
-        raise HTTPException(status_code=500, detail=f"转发失败：{str(e)}")
+        raise HTTPException(status_code=500, detail="更新API密钥运行时间失败！")
+
+    return Response(
+        content=response.content,
+        status_code=response.status_code,
+        headers=dict(response.headers)
+    )
 
-async def get_api_key(model: str = None):
+async def get_api_key_info(model: str = None):
     try:
         # 根据用户提供的SQL语句修改，从 'airs_model_api_keys_view' 视图中获取 'api_key'
         if model:
-            response = supabase.from_('airs_model_api_keys_view').select('api_key').eq('model_name', model).order('api_key_ran_at', desc=False).limit(1).execute()
-            # print(response.data)
+            response = supabase.from_('airs_model_api_keys_view').select('api_key', 'api_key_id').eq('model_name', model).order('api_key_ran_at', desc=False).limit(1).execute()
         else:
             # 如果没有提供model，则获取所有模型的api_key
             raise HTTPException(status_code=400, detail="请提供模型名称！")
-            # response = supabase.from_('airs_model_api_keys_view').select('api_key').order('api_key_ran_at', desc=False).limit(1).execute()
         
         if response.data:
-            # 由于已经limit(1)，直接返回第一条记录
-            return response.data[0]['api_key']
+            api_key_info = response.data[0]
+            return api_key_info
         else:
             return None
     except Exception as e:
         print(f"从Supabase获取API密钥失败: {e}")
         return None
+
+async def make_send_req(request: Request, protocol: ProtocolType, host:str, path: str):
+    _method = request.method
+    _url = f"{protocol.value}://{host}/{path}"
+    _headers = dict(request.headers)
+    # 移除FastAPI自带的Host头，避免Gemini校验报错
+    _headers.pop("host", None)
+    _headers.pop("authorization", None)
+    _headers.pop("user-agent", None)
+    _headers.pop("content-length", None)
+    # 将User-Agent改为curl/8.7.1，以模拟curl请求
+    _headers["User-Agent"] = "curl/8.7.1"
+
+    try:
+        # 读取客户端请求体
+        _content = await request.body()
+        content_json = json.loads(_content)
+        try:
+            _model = content_json.get("model")
+        except Exception as e:
+            print(f"获取模型名称失败: {e}")
+            return None
+    except Exception as e:
+        print(f"读取客户端请求体失败: {e}")
+        return None
+    _api_key_info = await get_api_key_info(_model)
+    _headers["Authorization"] = f"Bearer {_api_key_info['api_key']}"
+
+    send_req={
+        "method": _method,
+        "url": _url,
+        "headers": _headers,
+        "content": _content,
+        "model": _model,
+        "api_key_info": _api_key_info
+    }
+    return send_req