update for random ref voice

app.py

@@ -850,260 +850,6 @@ def cleanup_session(session_id):
         # Remove session
         del app.tts_sessions[session_id]
 
-
-@app.route("/api/conversational/generate", methods=["POST"])
-@limiter.limit("5 per minute")
-def generate_podcast():
-    # If verification not setup, handle it first
-    if app.config["TURNSTILE_ENABLED"] and not session.get("turnstile_verified"):
-        return jsonify({"error": "Turnstile verification required"}), 403
-
-    data = request.json
-    script = data.get("script")
-
-    if not script or not isinstance(script, list) or len(script) < 2:
-        return jsonify({"error": "Invalid script format or too short"}), 400
-
-    # Validate script format
-    for line in script:
-        if not isinstance(line, dict) or "text" not in line or "speaker_id" not in line:
-            return (
-                jsonify(
-                    {
-                        "error": "Invalid script line format. Each line must have text and speaker_id"
-                    }
-                ),
-                400,
-            )
-        if (
-            not line["text"]
-            or not isinstance(line["speaker_id"], int)
-            or line["speaker_id"] not in [0, 1]
-        ):
-            return (
-                jsonify({"error": "Invalid script content. Speaker ID must be 0 or 1"}),
-                400,
-            )
-
-    # Get two conversational models (currently only CSM and PlayDialog)
-    available_models = Model.query.filter_by(
-        model_type=ModelType.CONVERSATIONAL, is_active=True
-    ).all()
-
-    if len(available_models) < 2:
-        return jsonify({"error": "Not enough conversational models available"}), 500
-
-    selected_models = get_weighted_random_models(available_models, 2, ModelType.CONVERSATIONAL)
-
-    try:
-        # Generate audio for both models concurrently
-        audio_files = []
-        model_ids = []
-
-        # Function to process a single model
-        def process_model(model):
-            # Call conversational TTS service
-            audio_content = predict_tts(script, model.id)
-
-            # Save to temp file with unique name
-            file_uuid = str(uuid.uuid4())
-            dest_path = os.path.join(TEMP_AUDIO_DIR, f"{file_uuid}.wav")
-
-            with open(dest_path, "wb") as f:
-                f.write(audio_content)
-
-            return {"model_id": model.id, "audio_path": dest_path}
-
-        # Use ThreadPoolExecutor to process models concurrently
-        with ThreadPoolExecutor(max_workers=2) as executor:
-            results = list(executor.map(process_model, selected_models))
-
-        # Extract results
-        for result in results:
-            model_ids.append(result["model_id"])
-            audio_files.append(result["audio_path"])
-
-        # Create session
-        session_id = str(uuid.uuid4())
-        script_text = " ".join([line["text"] for line in script])
-        app.conversational_sessions[session_id] = {
-            "model_a": model_ids[0],
-            "model_b": model_ids[1],
-            "audio_a": audio_files[0],
-            "audio_b": audio_files[1],
-            "text": script_text[:1000],  # Limit text length
-            "created_at": datetime.utcnow(),
-            "expires_at": datetime.utcnow() + timedelta(minutes=30),
-            "voted": False,
-            "script": script,
-        }
-
-        # Return audio file paths and session
-        return jsonify(
-            {
-                "session_id": session_id,
-                "audio_a": f"/api/conversational/audio/{session_id}/a",
-                "audio_b": f"/api/conversational/audio/{session_id}/b",
-                "expires_in": 1800,  # 30 minutes in seconds
-            }
-        )
-
-    except Exception as e:
-        app.logger.error(f"Conversational generation error: {str(e)}")
-        return jsonify({"error": f"Failed to generate podcast: {str(e)}"}), 500
-
-
-@app.route("/api/conversational/audio/<session_id>/<model_key>")
-def get_podcast_audio(session_id, model_key):
-    # If verification not setup, handle it first
-    if app.config["TURNSTILE_ENABLED"] and not session.get("turnstile_verified"):
-        return jsonify({"error": "Turnstile verification required"}), 403
-
-    if session_id not in app.conversational_sessions:
-        return jsonify({"error": "Invalid or expired session"}), 404
-
-    session_data = app.conversational_sessions[session_id]
-
-    # Check if session expired
-    if datetime.utcnow() > session_data["expires_at"]:
-        cleanup_conversational_session(session_id)
-        return jsonify({"error": "Session expired"}), 410
-
-    if model_key == "a":
-        audio_path = session_data["audio_a"]
-    elif model_key == "b":
-        audio_path = session_data["audio_b"]
-    else:
-        return jsonify({"error": "Invalid model key"}), 400
-
-    # Check if file exists
-    if not os.path.exists(audio_path):
-        return jsonify({"error": "Audio file not found"}), 404
-
-    return send_file(audio_path, mimetype="audio/wav")
-
-
-@app.route("/api/conversational/vote", methods=["POST"])
-@limiter.limit("30 per minute")
-def submit_podcast_vote():
-    # If verification not setup, handle it first
-    if app.config["TURNSTILE_ENABLED"] and not session.get("turnstile_verified"):
-        return jsonify({"error": "Turnstile verification required"}), 403
-
-    data = request.json
-    session_id = data.get("session_id")
-    chosen_model_key = data.get("chosen_model")  # "a" or "b"
-
-    if not session_id or session_id not in app.conversational_sessions:
-        return jsonify({"error": "Invalid or expired session"}), 404
-
-    if not chosen_model_key or chosen_model_key not in ["a", "b"]:
-        return jsonify({"error": "Invalid chosen model"}), 400
-
-    session_data = app.conversational_sessions[session_id]
-
-    # Check if session expired
-    if datetime.utcnow() > session_data["expires_at"]:
-        cleanup_conversational_session(session_id)
-        return jsonify({"error": "Session expired"}), 410
-
-    # Check if already voted
-    if session_data["voted"]:
-        return jsonify({"error": "Vote already submitted for this session"}), 400
-
-    # Get model IDs and audio paths
-    chosen_id = (
-        session_data["model_a"] if chosen_model_key == "a" else session_data["model_b"]
-    )
-    rejected_id = (
-        session_data["model_b"] if chosen_model_key == "a" else session_data["model_a"]
-    )
-    chosen_audio_path = (
-        session_data["audio_a"] if chosen_model_key == "a" else session_data["audio_b"]
-    )
-    rejected_audio_path = (
-        session_data["audio_b"] if chosen_model_key == "a" else session_data["audio_a"]
-    )
-
-    # Record vote in database
-    user_id = current_user.id if current_user.is_authenticated else None
-    vote, error = record_vote(
-        user_id, session_data["text"], chosen_id, rejected_id, ModelType.CONVERSATIONAL
-    )
-
-    if error:
-        return jsonify({"error": error}), 500
-
-    # --- Save preference data ---\
-    try:
-        vote_uuid = str(uuid.uuid4())
-        vote_dir = os.path.join("./votes", vote_uuid)
-        os.makedirs(vote_dir, exist_ok=True)
-
-        # Copy audio files
-        shutil.copy(chosen_audio_path, os.path.join(vote_dir, "chosen.wav"))
-        shutil.copy(rejected_audio_path, os.path.join(vote_dir, "rejected.wav"))
-
-        # Create metadata
-        chosen_model_obj = Model.query.get(chosen_id)
-        rejected_model_obj = Model.query.get(rejected_id)
-        metadata = {
-            "script": session_data["script"], # Save the full script
-            "chosen_model": chosen_model_obj.name if chosen_model_obj else "Unknown",
-            "chosen_model_id": chosen_model_obj.id if chosen_model_obj else "Unknown",
-            "rejected_model": rejected_model_obj.name if rejected_model_obj else "Unknown",
-            "rejected_model_id": rejected_model_obj.id if rejected_model_obj else "Unknown",
-            "session_id": session_id,
-            "timestamp": datetime.utcnow().isoformat(),
-            "username": current_user.username if current_user.is_authenticated else None,
-            "model_type": "CONVERSATIONAL"
-        }
-        with open(os.path.join(vote_dir, "metadata.json"), "w") as f:
-            json.dump(metadata, f, indent=2)
-
-    except Exception as e:
-        app.logger.error(f"Error saving preference data for conversational vote {session_id}: {str(e)}")
-        # Continue even if saving preference data fails, vote is already recorded
-
-    # Mark session as voted
-    session_data["voted"] = True
-
-    # Return updated models (use previously fetched objects)
-    return jsonify(
-        {
-            "success": True,
-            "chosen_model": {"id": chosen_id, "name": chosen_model_obj.name if chosen_model_obj else "Unknown"},
-            "rejected_model": {
-                "id": rejected_id,
-                "name": rejected_model_obj.name if rejected_model_obj else "Unknown",
-            },
-            "names": {
-                "a": Model.query.get(session_data["model_a"]).name,
-                "b": Model.query.get(session_data["model_b"]).name,
-            },
-        }
-    )
-
-
-def cleanup_conversational_session(session_id):
-    """Remove conversational session and its audio files"""
-    if session_id in app.conversational_sessions:
-        session = app.conversational_sessions[session_id]
-
-        # Remove audio files
-        for audio_file in [session["audio_a"], session["audio_b"]]:
-            if os.path.exists(audio_file):
-                try:
-                    os.remove(audio_file)
-                except Exception as e:
-                    app.logger.error(
-                        f"Error removing conversational audio file: {str(e)}"
-                    )
-
-        # Remove session
-        del app.conversational_sessions[session_id]
-
-
 # Schedule periodic cleanup
 def setup_cleanup():
     def cleanup_expired_sessions():
@@ -1375,6 +1121,14 @@ def get_reference_audio(filename):
         return jsonify({"error": "Reference audio not found"}), 404
     return send_file(file_path, mimetype="audio/wav")
 
+@app.route('/api/voice/random', methods=['GET'])
+def get_random_voice():
+    # 随机选择一个音频文件
+    random_voice = random.choice(reference_audio_files)
+    voice_path = os.path.join(REFERENCE_AUDIO_DIR, random_voice)
+
+    # 返回音频文件
+    return send_file(voice_path, mimetype='audio/' + voice_path.split('.')[-1])
 
 def get_weighted_random_models(
     applicable_models: list[Model], num_to_select: int, model_type: ModelType