Update app.py

app.py

@@ -1,19 +1,21 @@
 import os
-import requests
-from fastapi import FastAPI
+import httpx
+from fastapi import FastAPI, HTTPException
 from datetime import datetime, timedelta
 from fastapi.middleware.cors import CORSMiddleware
 from fastmcp.server import FastMCP
 from contextlib import asynccontextmanager
+from typing import List, Dict, Optional
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
+    # 初始化时获取数据
     await fetch_github_trending()
     yield
 
 app = FastAPI(lifespan=lifespan)
 
-# 更宽松的 CORS 配置
+# CORS 配置
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -24,14 +26,15 @@ app.add_middleware(
 )
 
 # 缓存设置
-cached_trending = []
-last_updated = None
+cached_trending: List[Dict] = []
+last_updated: Optional[datetime] = None
+GITHUB_API_URL = "https://api.github.com/search/repositories"
+CACHE_EXPIRY = timedelta(minutes=30)
 
-async def fetch_github_trending():
+async def fetch_github_trending() -> List[Dict]:
     """获取 GitHub 热门项目"""
     global cached_trending, last_updated
     
-    url = "https://api.github.com/search/repositories"
     params = {
         "q": "stars:>1000",
         "sort": "stars",
@@ -39,57 +42,130 @@ async def fetch_github_trending():
         "per_page": 10
     }
     
-    headers = {}
+    headers = {
+        "Accept": "application/vnd.github.v3+json",
+        "User-Agent": "GitHub-Trending-API"
+    }
+    
     if github_token := os.getenv("GITHUB_TOKEN"):
         headers["Authorization"] = f"token {github_token}"
     
     try:
-        response = requests.get(url, params=params, headers=headers)
-        response.raise_for_status()
-        cached_trending = [
-            {
-                "name": item["full_name"],
-                "url": item["html_url"],
-                "stars": item["stargazers_count"],
-                "description": item["description"],
-                "language": item["language"]
-            }
-            for item in response.json().get("items", [])
-        ]
-        last_updated = datetime.now()
-        return cached_trending
+        async with httpx.AsyncClient() as client:
+            response = await client.get(
+                GITHUB_API_URL,
+                params=params,
+                headers=headers,
+                timeout=10.0
+            )
+            response.raise_for_status()
+            
+            cached_trending = [
+                {
+                    "name": item["full_name"],
+                    "url": item["html_url"],
+                    "stars": item["stargazers_count"],
+                    "description": item["description"],
+                    "language": item["language"]
+                }
+                for item in response.json().get("items", [])
+            ]
+            last_updated = datetime.now()
+            return cached_trending
+            
+    except httpx.HTTPStatusError as e:
+        print(f"GitHub API error: {e.response.status_code} - {e.response.text}")
+        if cached_trending:
+            return cached_trending
+        raise HTTPException(
+            status_code=429,
+            detail="GitHub API rate limit exceeded. Please try again later."
+        )
     except Exception as e:
         print(f"Error fetching GitHub trending: {e}")
-        return cached_trending if cached_trending else []
+        if cached_trending:
+            return cached_trending
+        raise HTTPException(
+            status_code=500,
+            detail="Failed to fetch trending repositories"
+        )
 
 # 初始化 MCP 服务器
 mcp_server = FastMCP(
-    name="GithubTrending"
+    name="GitHubTrendingAPI",
+    description="Access GitHub trending repositories"
 )
 
 @mcp_server.tool()
-def get_trending_repos(num: int = 10) -> dict:
+async def get_trending_repos(num: int = 10) -> dict:
     """获取 GitHub 热门仓库"""
-    if not last_updated or (datetime.now() - last_updated) > timedelta(minutes=5):
-        fetch_github_trending()
+    if not last_updated or (datetime.now() - last_updated) > CACHE_EXPIRY:
+        await fetch_github_trending()
     return {"trending": cached_trending[:num]}
 
-# 关键修改：确保正确挂载 MCP 服务
+# 挂载 MCP 服务
 app.mount("/mcp", mcp_server.http_app())
 
 @app.get("/")
 async def root():
-    return {"message": "GitHub Trending API is running"}
+    return {
+        "message": "GitHub Trending API is running",
+        "documentation": "/docs",
+        "mcp_endpoint": "/mcp",
+        "trending_endpoint": "/trending"
+    }
 
 @app.get("/trending")
-async def get_trending():
+async def get_trending(num: int = 10):
     """公开的 HTTP 端点"""
-    if not cached_trending or (datetime.now() - last_updated) > timedelta(minutes=5):
+    if not cached_trending or (datetime.now() - last_updated) > CACHE_EXPIRY:
         await fetch_github_trending()
     
     return {
-        "trending": cached_trending,
+        "trending": cached_trending[:num],
         "last_updated": last_updated.isoformat() if last_updated else None,
-        "cache_expires_in": 300,
-        "suggested_polling_interval": 60
-    }
+        "cache_expires_in": CACHE_EXPIRY.total_seconds(),
+        "rate_limit_info": "Consider adding a GitHub token for higher rate limits"
+    }
+
+
+@app.get("/trending/stream")
+async def stream_trending(interval: int = 60, client_id: str = None):
+    """增强版 SSE 端点"""
+    async def event_generator():
+        try:
+            while True:
+                # 发送心跳
+                yield {"event": "heartbeat", "data": ""}
+                
+                # 获取数据
+                if not last_updated or (datetime.now() - last_updated) > timedelta(seconds=interval):
+                    await fetch_github_trending()
+                
+                yield {
+                    "event": "update",
+                    "data": json.dumps({
+                        "trending": cached_trending[:10],
+                        "last_updated": last_updated.isoformat(),
+                        "client_id": client_id,
+                        "next_update": (datetime.now() + timedelta(seconds=interval)).isoformat()
+                    })
+                }
+                
+                await asyncio.sleep(interval)
+                
+        except asyncio.CancelledError:
+            print(f"客户端断开连接: {client_id}")
+        except Exception as e:
+            print(f"SSE 错误: {e}")
+
+    response = StreamingResponse(
+        event_generator(),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "X-Accel-Buffering": "no"  # 针对 Nginx 的优化
+        }
+    )
+    return response