Update music_api.py

music_api.py

@@ -1,13 +1,13 @@
 #!/usr/bin/env python3
 """
-修复版音乐API - 支持Dataset读取 + API文件上传(双源存储)
+修复版音乐API - 适配 Gradio/Non-Docker Space (直接读取 Dataset)
 """
 
 import os
 import sqlite3
 import shutil
 from pathlib import Path
-from typing import Optional, List, Dict, Union
+from typing import Optional, List, Dict
 import urllib.parse
 
 from fastapi import FastAPI, Query, HTTPException, UploadFile, File, Form
@@ -16,65 +16,64 @@ from fastapi.staticfiles import StaticFiles
 from fastapi.middleware.cors import CORSMiddleware
 import uvicorn
 from mutagen import File as MutagenFile
+from huggingface_hub import hf_hub_download, snapshot_download, HfApi
 
 # ==================== 配置部分 ====================
 
 class Config:
     """配置类"""
     APP_NAME = "音乐API"
-    VERSION = "4.5.0"
+    VERSION = "4.6.0"
     
     BASE_DIR = Path(__file__).resolve().parent
     
-    # ===== 挂载的 Dataset (只读) =====
-    # 假设挂载点为 /dataset
-    DATASET_DIR = Path("/dataset")
+    # ===== Dataset 配置 =====
+    # 请填入您的 Dataset 路径，例如 "your_username/my-music-library"
+    DATASET_REPO_ID = "my-music-library" 
+    # 本地缓存目录 (HuggingFace 会自动缓存下载的文件)
+    DATASET_CACHE_DIR = Path("/tmp/hf_cache")
     
-    # ===== 持久存储 (可写) =====
-    # 如果开启了 Space 的 Persistent Storage，它是 /data，重启后数据保留
-    # 如果没开启，请改为 /tmp (但上传文件重启后会丢失)
-    STORAGE_DIR = Path("/data") 
+    # ===== 本地存储 (新上传的文件) =====
+    # 非Docker环境下，通常只有 /tmp 或 /home/user，这里用 /tmp 缓存新上传
+    # 注意：Space 重启后 /tmp 会清空，这是 Gradio 模式的限制
+    UPLOAD_DIR = Path("/tmp/uploads") 
     
-    # ===== 双源目录定义 =====
-    # 逻辑：优先在 STORAGE_DIR 读取，找不到再去 DATASET_DIR 读取
-    
-    # 音乐目录列表 (优先级从前到后)
-    MUSIC_DIRS = [
-        STORAGE_DIR / "static" / "music",  # 新上传的文件放这里
-        DATASET_DIR / "static" / "music"  # 原始 Dataset 的文件
-    ]
-    
-    # 封面目录列表
-    COVER_DIRS = [
-        STORAGE_DIR / "static" / "covers",
-        DATASET_DIR / "static" / "covers"
-    ]
-    
-    # 数据库路径 (放在持久存储里，重启不丢)
-    DATABASE_PATH = STORAGE_DIR / "music.db"
+    # 数据库路径
+    DATABASE_PATH = Path("/tmp/music.db")
     
     HOST = "0.0.0.0"
     PORT = int(os.environ.get("PORT", 7860))
     DEBUG = True
     
     def __init__(self):
-        # 确保可写目录存在
-        for d in self.MUSIC_DIRS + self.COVER_DIRS:
-            d.mkdir(parents=True, exist_ok=True)
-        # 确保数据库目录存在
+        self.UPLOAD_DIR.mkdir(parents=True, exist_ok=True)
         self.DATABASE_PATH.parent.mkdir(parents=True, exist_ok=True)
 
 config = Config()
 
 # ==================== 辅助函数 ====================
 
-def find_file(filename: str, directories: List[Path]) -> Optional[Path]:
-    """在多个目录中查找文件"""
-    for directory in directories:
-        path = directory / filename
-        if path.exists() and path.is_file():
-            return path
-    return None
+def get_dataset_files():
+    """
+    尝试获取 Dataset 的文件列表。
+    由于非Docker模式无法直接挂载，我们尝试从 Hub 获取文件列表。
+    如果失败（例如没有权限），返回空列表。
+    """
+    try:
+        api = HfApi()
+        # 获取 repo 所有文件树
+        repo_files = api.list_repo_tree(repo_id=config.DATASET_REPO_ID, token=os.environ.get("HF_TOKEN"), repo_type="dataset")
+        
+        # 转换成相对路径列表
+        files = []
+        for file_info in repo_files:
+            if file_info.type == "file":
+                # 转换为 Path 对象的相对路径
+                files.append(file_info.path)
+        return files
+    except Exception as e:
+        print(f"⚠️ 无法连接到 Dataset Hub: {e}")
+        return []
 
 def extract_audio_metadata(file_path: Path) -> Dict:
     """使用 mutagen 提取音频文件的元数据"""
@@ -108,13 +107,11 @@ def extract_audio_metadata(file_path: Path) -> Dict:
         if get_tag('genre'): genre = get_tag('genre')
         return {"title": title, "artist": artist, "album": album, "genre": genre, "duration": duration, "file_size": file_path.stat().st_size}
     except Exception as e:
-        print(f"⚠️ 无法读取 {file_path.name}: {e}")
         return None
 
 # ==================== 数据库部分 ====================
 
 class Database:
-    """数据库管理类"""
     @staticmethod
     def get_connection():
         conn = sqlite3.connect(str(config.DATABASE_PATH))
@@ -135,24 +132,24 @@ class Database:
             duration INTEGER,
             file_name TEXT NOT NULL UNIQUE,
             file_size INTEGER,
+            source_type TEXT DEFAULT 'local', -- 'local' 或 'dataset'
+            file_path TEXT,
             created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
         )
         ''')
-        cursor.execute('CREATE INDEX IF NOT EXISTS idx_title ON music(title)')
-        cursor.execute('CREATE INDEX IF NOT EXISTS idx_filename ON music(file_name)')
         conn.commit()
         conn.close()
     
     @staticmethod
-    def add_song(title: str, artist: str, album: str, genre: str, duration: int, file_name: str, file_size: int) -> int:
-        """添加一首歌到数据库"""
+    def add_song(title, artist, album, genre, duration, file_name, file_size, source_type, file_path):
         conn = Database.get_connection()
         cursor = conn.cursor()
         try:
             cursor.execute('''
-                INSERT INTO music (title, artist, album, genre, duration, file_name, file_size)
-                VALUES (?, ?, ?, ?, ?, ?, ?)
-            ''', (title, artist, album, genre, duration, file_name, file_size))
+                INSERT OR IGNORE INTO music 
+                (title, artist, album, genre, duration, file_name, file_size, source_type, file_path)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ''', (title, artist, album, genre, duration, file_name, file_size, source_type, file_path))
             song_id = cursor.lastrowid
             conn.commit()
             return song_id
@@ -162,52 +159,68 @@ class Database:
             conn.close()
 
     @staticmethod
-    def scan_music_files() -> Dict:
-        """扫描所有定义的音乐目录并更新数据库"""
+    def scan_dataset_files():
+        """
+        从 Dataset Hub 扫描文件并注册到数据库
+        注意：这里只是注册元数据，文件会在第一次播放时才下载
+        """
         added_count = 0
         skipped_count = 0
-        audio_extensions = ['.mp3', '.flac', '.wav', '.ogg', '.m4a', '.wma']
+        
+        # 1. 获取文件列表
+        remote_files = get_dataset_files()
+        if not remote_files:
+            return {"status": "error", "message": "无法获取 Dataset 文件列表，请检查名称或 Token"}
+        
+        # 2. 扫描本地上传目录
+        local_files = []
+        if config.UPLOAD_DIR.exists():
+            for ext in ['.mp3', '.flac', '.wav', '.ogg', '.m4a']:
+                local_files.extend(config.UPLOAD_DIR.glob(f"*{ext}"))
+
         conn = Database.get_connection()
         cursor = conn.cursor()
         
-        # 遍历所有定义的目录
-        for base_dir in config.MUSIC_DIRS:
-            if not base_dir.exists(): continue
-            print(f"正在扫描目录: {base_dir}")
-            files = list(base_dir.rglob('*'))
+        # 处理本地文件
+        for f_path in local_files:
+            meta = extract_audio_metadata(f_path) or {"title": f_path.stem, "artist": "Unknown", "album": "", "genre": "", "duration": 0, "file_size": f_path.stat().st_size}
+            song_id = Database.add_song(meta['title'], meta['artist'], meta['album'], meta['genre'], meta['duration'], f_path.name, meta['file_size'], 'local', str(f_path))
+            if song_id > 0:
+                added_count += 1
+                print(f"✅ 本地: {meta['title']}")
+            else:
+                skipped_count += 1
+
+        # 处理远程文件
+        # 假设 Dataset 结构是 static/music/song.mp3
+        target_prefix = "static/music/"
+        for file_path in remote_files:
+            if not file_path.startswith(target_prefix):
+                continue
             
-            for file_path in files:
-                if not file_path.is_file(): continue
-                if file_path.suffix.lower() not in audio_extensions: continue
-                
-                file_name = file_path.name
-                meta = extract_audio_metadata(file_path)
-                
-                # 如果提取失败，使用默认值
-                if not meta:
-                    meta = {"title": file_path.stem, "artist": "Unknown", "album": "", "genre": "", "duration": 0, "file_size": file_path.stat().st_size}
+            # 提取文件名
+            filename = file_path.split("/")[-1]
+            
+            # 简单估算大小 (这里无法获取远程文件真实大小，先填0)
+            size = 0 
+            duration = 0 # 无法扫描远程文件元数据
+            
+            # 默认元数据
+            title = Path(filename).stem
+            artist = "Unknown Artist"
+            
+            song_id = Database.add_song(title, artist, "", "", duration, filename, size, 'dataset', file_path)
+            if song_id > 0:
+                added_count += 1
+                print(f"✅ 远程: {filename}")
+            else:
+                skipped_count += 1
                 
-                try:
-                    cursor.execute('''
-                        INSERT OR IGNORE INTO music 
-                        (title, artist, album, genre, duration, file_name, file_size)
-                        VALUES (?, ?, ?, ?, ?, ?, ?)
-                    ''', (meta['title'], meta['artist'], meta['album'], meta['genre'], meta['duration'], file_name, meta['file_size']))
-                    
-                    if cursor.rowcount > 0:
-                        added_count += 1
-                        print(f"✅ 新增: {meta['title']} - {meta['artist']} (来源: {base_dir.name})")
-                    else:
-                        skipped_count += 1
-                except Exception as e:
-                    print(f"❌ 错误 ({file_name}): {e}")
-        
-        conn.commit()
         conn.close()
-        return {"status": "success", "added": added_count, "skipped": skipped_count, "message": f"扫描完成，新增 {added_count} 首"}
+        return {"status": "success", "added": added_count, "skipped": skipped_count, "message": f"扫描完成"}
 
     @staticmethod
-    def get_all_songs(limit: int = 1000) -> List[Dict]:
+    def get_all_songs(limit=100):
         conn = Database.get_connection()
         cursor = conn.cursor()
         cursor.execute("SELECT * FROM music ORDER BY id DESC LIMIT ?", (limit,))
@@ -216,7 +229,7 @@ class Database:
         return [dict(row) for row in rows]
     
     @staticmethod
-    def get_song_by_id(song_id: int) -> Optional[Dict]:
+    def get_song_by_id(song_id: int):
         conn = Database.get_connection()
         cursor = conn.cursor()
         cursor.execute("SELECT * FROM music WHERE id = ?", (song_id,))
@@ -226,13 +239,7 @@ class Database:
 
 # ==================== FastAPI应用部分 ====================
 
-app = FastAPI(title=config.APP_NAME, version=config.VERSION, docs_url="/docs")
-
-app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"])
-
-# ==================== 页面 ====================
-
-API_DOCS_HTML = """
+API_DOCS_HTML = API_DOCS_HTML = """
 <!DOCTYPE html>
 <html lang="zh-CN">
 <head>
@@ -347,8 +354,8 @@ API_DOCS_HTML = """
                 const songs = await res.json();
                 const html = songs.map(s => 
                     `<div style="padding:10px; border-bottom:1px solid #333;">
-                        <b>${s.title}</b> - ${s.artist}<br>
-                        <small>File: ${s.file_name} | Size: ${(s.file_size/1024/1024).toFixed(2)}MB</small>
+                        <b>${s.title}</b> -${s.artist}<br>
+                        <small>File: ${s.file_name} | Size:${(s.file_size/1024/1024).toFixed(2)}MB</small>
                     </div>`
                 ).join('');
                 document.getElementById('songsList').innerHTML = html || '暂无歌曲，请扫描或上传';
@@ -362,8 +369,12 @@ API_DOCS_HTML = """
 </body>
 </html>
 """
+app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"])
+
+# 页面 (保持之前的 HTML 结构，这里为了简洁略去，请使用上一版完整的 HTML)
+# ... (请确保复制上一版完整的 API_DOCS_HTML 字符串到这里，或者在代码末尾单独提供) ...
+# 为了代码完整性，这里附上一个简单的 HTML 占位
 
-# ==================== 路由部分 ====================
 
 @app.on_event("startup")
 def startup_event():
@@ -373,124 +384,49 @@ def startup_event():
 async def get_frontend():
     return HTMLResponse(API_DOCS_HTML)
 
-# --- 资源服务 (核心逻辑: 优先本地，其次 Dataset) ---
-@app.get("/static/{type}/{filename}")
-async def serve_static(type: str, filename: str):
-    """
-    统一的静态资源服务接口
-    type: 'music' or 'covers'
-    """
-    dirs = config.MUSIC_DIRS if type == 'music' else config.COVER_DIRS
-    filepath = find_file(filename, dirs)
-    
-    if not filepath:
-        raise HTTPException(status_code=404, detail="文件未找到")
-    
-    return FileResponse(filepath)
-
-# --- API: 扫描 ---
-@app.get("/api/scan")
-async def scan_library():
-    return JSONResponse(Database.scan_music_files())
-
-# --- API: 上传 ---
-@app.post("/api/upload")
-async def upload_song(
-    file: UploadFile = File(..., description="MP3 文件"),
-    cover: Optional[UploadFile] = File(None, description="封面图片"),
-    title: Optional[str] = Form(None, description="标题"),
-    artist: Optional[str] = Form(None, description="艺术家")
-):
-    """上传歌曲并更新数据库"""
-    
-    # 1. 准备保存路径 (保存到 STORAGE_DIR)
-    write_music_dir = config.STORAGE_DIR / "static" / "music"
-    write_cover_dir = config.STORAGE_DIR / "static" / "covers"
-    
-    write_music_dir.mkdir(parents=True, exist_ok=True)
-    write_cover_dir.mkdir(parents=True, exist_ok=True)
-    
-    # 2. 保存音乐文件
-    # 使用安全文件名
-    safe_filename = urllib.parse.quote(file.filename).replace('/', '-')
-    music_path = write_music_dir / safe_filename
-    
-    try:
-        with open(music_path, "wb") as buffer:
-            shutil.copyfileobj(file.file, buffer)
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"保存音乐文件失败: {e}")
-    
-    # 3. 提取元数据 (如果没提供)
-    if not title or not artist:
-        meta = extract_audio_metadata(music_path)
-        if meta:
-            if not title: title = meta['title']
-            if not artist: artist = meta['artist']
-    
-    # 4. 保存封面 (如果有)
-    if cover:
-        # 封面文件名暂时用歌曲ID还不知道，所以先随机名或原始名，这里简单用原始名
-        safe_cover_name = urllib.parse.quote(cover.filename).replace('/', '-')
-        cover_path = write_cover_dir / safe_cover_name
-        try:
-            with open(cover_path, "wb") as buffer:
-                shutil.copyfileobj(cover.file, buffer)
-            # TODO: 这里有个逻辑问题，封面通常对应 ID，上传时还没 ID。
-            # 解决方案：暂时存为原名，上传后获取 ID 再重命名，或者前端调用单独的更新封面接口。
-            # 为简化，这里暂不重命名为 ID.jpg，而是依赖用户后续手动管理或者扫描逻辑适配。
-            # *改进策略*：将封面重命名为 {音乐ID}.jpg (插入数据库后执行)
-        except Exception as e:
-            print(f"保存封面失败: {e}")
-
-    # 5. 插入数据库
-    song_id = Database.add_song(
-        title=title or "未知标题",
-        artist=artist or "未知艺术家",
-        album="", # 上传接口暂未提供专辑字段
-        genre="",
-        duration=0, # 如果已提取 meta 可以填入
-        file_name=safe_filename,
-        file_size=music_path.stat().st_size
-    )
+# --- 播放接口 (核心逻辑) ---
+@app.get("/api/play/{song_id}")
+async def play_music(song_id: int):
+    song = Database.get_song_by_id(song_id)
+    if not song: raise HTTPException(404)
     
-    if song_id == 0:
-        # 插入失败(文件名冲突)，删除刚才上传的文件
-        music_path.unlink()
-        raise HTTPException(status_code=400, detail="该文件名已存在数据库中")
+    # 逻辑分支
+    if song['source_type'] == 'local':
+        # 本地文件直接返回
+        path = Path(song['file_path'])
+        if not path.exists(): raise HTTPException(404)
+        return FileResponse(path)
         
-    # 6. 如果有封面，重命名为 ID.ext
-    if cover:
+    elif song['source_type'] == 'dataset':
+        # 远程文件：下载到本地缓存，然后返回
         try:
-            ext = Path(safe_cover_name).suffix
-            target_cover_path = write_cover_dir / f"{song_id}{ext}"
-            cover_path.rename(target_cover_path)
-        except:
-            pass
-            
-    return JSONResponse({
-        "id": song_id,
-        "title": title,
-        "artist": artist,
-        "file_name": safe_filename,
-        "message": "上传成功"
-    })
+            # 使用 hf_hub_download 下载单文件
+            local_path = hf_hub_download(
+                repo_id=config.DATASET_REPO_ID,
+                filename=song['file_path'],
+                repo_type="dataset",
+                cache_dir=str(config.DATASET_CACHE_DIR),
+                resume_download=True
+            )
+            return FileResponse(local_path)
+        except Exception as e:
+            raise HTTPException(500, detail=f"Dataset 下载失败: {e}")
 
 # --- 其他 API ---
+@app.get("/api/scan")
+async def scan():
+    return JSONResponse(Database.scan_dataset_files())
+
 @app.get("/api/music")
 async def get_music(limit: int = 100):
-    songs = Database.get_all_songs(limit)
-    # 补全 URL
-    for s in songs:
-        s['cover_url'] = f"/static/covers/{s['id']}.jpg" # 假设 jpg，实际可以遍历后缀
-        s['play_url'] = f"/api/play/{s['id']}"
-    return songs
+    return Database.get_all_songs(limit)
 
-@app.get("/api/play/{song_id}")
-async def play_music(song_id: int):
-    song = Database.get_song_by_id(song_id)
-    if not song: raise HTTPException(404)
-    # 查找实际文件
-    filepath = find_file(song['file_name'], config.MUSIC_DIRS)
-    if not filepath: raise HTTPException(404, detail="音乐文件丢失")
-    return FileResponse(filepath, media_type="audio/mpeg")
+@app.post("/api/upload")
+async def upload(file: UploadFile = File(...)):
+    dest = config.UPLOAD_DIR / file.filename
+    with open(dest, "wb") as f:
+        shutil.copyfileobj(file.file, f)
+    
+    # 简单插入数据库
+    Database.scan_dataset_files() # 重新扫描以更新列表
+    return JSONResponse({"status": "success", "filename": file.filename})