Initial commit of Voice Detection System

.gitignore

@@ -0,0 +1,5 @@
+__pycache__/
+*.pyc
+uploads/
+*.mp3
+.fastapi_cache/

audio_processor.py

@@ -0,0 +1,56 @@
+import shutil
+import os
+import requests
+import uuid
+from urllib.parse import urlparse
+from fastapi import UploadFile, HTTPException
+
+UPLOAD_DIR = "uploads"
+os.makedirs(UPLOAD_DIR, exist_ok=True)
+
+async def download_audio_from_url(url: str) -> str:
+    try:
+        response = requests.get(url, stream=True)
+        response.raise_for_status()
+        
+        # Parse URL to get path and extension, ignoring query params
+        parsed_url = urlparse(url)
+        path = parsed_url.path
+        ext = os.path.splitext(path)[1]
+        
+        if not ext:
+            ext = ".mp3" # Default to mp3 if no extension found
+            
+        # Generate a safe filename
+        filename = f"{uuid.uuid4()}{ext}"
+        
+        file_location = f"{UPLOAD_DIR}/{filename}"
+        with open(file_location, "wb") as f:
+            for chunk in response.iter_content(chunk_size=8192):
+                 f.write(chunk)
+        return file_location
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Failed to download audio: {str(e)}")
+
+async def process_audio(file: UploadFile = None, audio_url: str = None):
+    if file:
+        file_location = f"{UPLOAD_DIR}/{file.filename}"
+        with open(file_location, "wb+") as file_object:
+            shutil.copyfileobj(file.file, file_object)
+        filename = file.filename
+    elif audio_url:
+        file_location = await download_audio_from_url(audio_url)
+        filename = os.path.basename(file_location)
+    else:
+        raise HTTPException(status_code=400, detail="No audio file or URL provided")
+    
+    # In a real scenario, use librosa or pydub to get duration/sample_rate
+    # For now, just return file size as a proxy for 'processed' metadata
+    file_size = os.path.getsize(file_location)
+    
+    return {
+        "filename": filename,
+        "size_bytes": file_size,
+        "format": filename.split(".")[-1],
+        "duration_seconds": 0.0 # Placeholder
+    }

auth.py

@@ -0,0 +1,8 @@
+from fastapi import Header, HTTPException
+
+API_KEY = "my_secret_key_123" # Simple hardcoded key for demo
+
+async def verify_api_key(x_api_key: str = Header(...)):
+    if x_api_key != API_KEY:
+        raise HTTPException(status_code=401, detail="Invalid API Key")
+    return x_api_key

detector.py

@@ -0,0 +1,20 @@
+import random
+
+def analyze_audio(metadata):
+    # Mock detection logic
+    # In a real app, this would use a model
+    
+    # Deterministic mock based on file size to be consistent for testing if needed, 
+    # or just random for demo. Let's make it random but weighted.
+    
+    is_human = random.choice([True, False])
+    confidence = round(random.uniform(0.70, 0.99), 2)
+    
+    return {
+        "is_human": is_human,
+        "confidence": confidence,
+        "detected_language": "multilingual",
+        "segments": [
+            {"start": 0.0, "end": 2.5, "label": "speech"}
+        ]
+    }

main.py

@@ -0,0 +1,58 @@
+from fastapi import FastAPI, UploadFile, File, Depends, HTTPException, Header, Form
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse
+from auth import verify_api_key
+from audio_processor import process_audio
+from detector import analyze_audio
+from murf_generator import generate_audio_with_murf
+from pydantic import BaseModel
+from typing import Optional
+
+app = FastAPI()
+
+app.mount("/static", StaticFiles(directory="static"), name="static")
+
+class AnalysisResponse(BaseModel):
+    status: str
+    analysis: dict
+    metadata: dict
+
+@app.post("/detect", response_model=AnalysisResponse)
+async def detect_voice(
+    file: UploadFile = File(None),
+    message: str = Form(None),
+    audio_url: str = Form(None),
+    x_api_key: str = Depends(verify_api_key)
+):
+    # validate file type if file is uploaded
+    if file and not file.filename.endswith(('.mp3', '.wav', '.m4a')):
+         raise HTTPException(status_code=400, detail="Invalid file format. Only audio files allowed.")
+    
+    if not file and not audio_url:
+        raise HTTPException(status_code=400, detail="Either file or audio_url is required.")
+    
+    # Process Audio (get metadata)
+    metadata = await process_audio(file, audio_url)
+    
+    # Run Detection
+    result = analyze_audio(metadata)
+    
+    return {
+        "status": "success",
+        "analysis": result,
+        "metadata": metadata
+    }
+
+class GenerateRequest(BaseModel):
+    text: str
+    murf_api_key: str
+    voice_id: Optional[str] = "en-US-marcus"
+
+@app.post("/generate")
+def generate_speech(request: GenerateRequest):
+    audio_url = generate_audio_with_murf(request.text, request.murf_api_key, request.voice_id)
+    return {"status": "success", "audio_url": audio_url}
+
+@app.get("/")
+def read_root():
+    return FileResponse('static/tester.html')

murf_generator.py

@@ -0,0 +1,50 @@
+import requests
+from fastapi import HTTPException
+
+# Murf API Endpoint
+MURF_API_URL = "https://api.murf.ai/v1/speech/generate"
+
+def generate_audio_with_murf(text: str, api_key: str, voice_id: str = "en-US-marcus") -> str:
+    """
+    Generates audio using Murf.ai API and returns the audio URL.
+    """
+    payload = {
+        "voiceId": voice_id,
+        "text": text,
+        "style": "General",
+        "rate": 0,
+        "pitch": 0,
+        "sampleRate": 24000,
+        "format": "MP3",
+        "channelType": "MONO",
+        "encodeAsBase64": False
+    }
+    
+    headers = {
+        "Content-Type": "application/json",
+        "Accept": "application/json",
+        "api-key": api_key
+    }
+    
+    try:
+        response = requests.post(MURF_API_URL, json=payload, headers=headers)
+        response.raise_for_status()
+        
+        data = response.json()
+        
+        # Check if URL is present in response
+        if "audioFile" in data:
+            return data["audioFile"]
+        elif "encodedAudio" in data:
+            raise HTTPException(status_code=500, detail="Received encoded audio but expected URL")
+        else:
+             raise HTTPException(status_code=500, detail=f"Unexpected response from Murf API: {data}")
+
+    except requests.exceptions.RequestException as e:
+        detail = str(e)
+        if e.response is not None:
+            try:
+                detail = e.response.json()
+            except:
+                detail = e.response.text
+        raise HTTPException(status_code=400, detail=f"Murf API Error: {detail}")

requirements.txt

@@ -0,0 +1,4 @@
+fastapi
+uvicorn
+python-multipart
+requests

static/tester.html

@@ -0,0 +1,214 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Voice Detection Verification Tool</title>
+    <style>
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            background-color: #f4f4f9;
+            color: #333;
+            padding: 20px;
+        }
+
+        .container {
+            max-width: 600px;
+            margin: 0 auto;
+            background: #fff;
+            padding: 30px;
+            border-radius: 8px;
+            box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
+        }
+
+        h1 {
+            text-align: center;
+            color: #444;
+        }
+
+        .form-group {
+            margin-bottom: 20px;
+        }
+
+        label {
+            display: block;
+            margin-bottom: 5px;
+            font-weight: bold;
+        }
+
+        input[type="text"],
+        input[type="url"],
+        textarea {
+            width: 100%;
+            padding: 10px;
+            border: 1px solid #ddd;
+            border-radius: 4px;
+            box-sizing: border-box;
+        }
+
+        button {
+            width: 100%;
+            padding: 12px;
+            background-color: #007bff;
+            color: white;
+            border: none;
+            border-radius: 4px;
+            cursor: pointer;
+            font-size: 16px;
+        }
+
+        button:hover {
+            background-color: #0056b3;
+        }
+
+        #response {
+            margin-top: 20px;
+            background: #f8f9fa;
+            padding: 15px;
+            border-radius: 4px;
+            border: 1px solid #ddd;
+            word-wrap: break-word;
+            white-space: pre-wrap;
+            display: none;
+        }
+
+        .error {
+            color: #dc3545;
+        }
+
+        .success {
+            color: #28a745;
+        }
+    </style>
+</head>
+
+<body>
+    <div class="container">
+        <h1>Voice Detection Tool</h1>
+
+        <div style="background: #e9ecef; padding: 15px; border-radius: 4px; margin-bottom: 20px;">
+            <h3>Generate AI Audio (Murf.ai)</h3>
+            <div class="form-group">
+                <label for="murfText">Text to Speak</label>
+                <input type="text" id="murfText" placeholder="Hello, this is a test.">
+            </div>
+            <div class="form-group">
+                <label for="murfKey">Murf API Key</label>
+                <input type="text" id="murfKey" placeholder="Enter Murf API Key">
+            </div>
+            <button onclick="generateAudio()" style="background-color: #28a745;">Generate Audio</button>
+            <div id="genStatus" style="margin-top:10px;"></div>
+        </div>
+
+        <div class="form-group">
+            <label for="apiUrl">API Endpoint URL</label>
+            <input type="text" id="apiUrl" value="http://127.0.0.1:8000/detect"
+                placeholder="http://127.0.0.1:8000/detect">
+        </div>
+
+        <div class="form-group">
+            <label for="apiKey">API Key (Authorization)</label>
+            <input type="text" id="apiKey" value="my_secret_key_123" placeholder="Enter API Key">
+        </div>
+
+        <div class="form-group">
+            <label for="message">Test Message (Optional)</label>
+            <textarea id="message" rows="2" placeholder="Describe this test..."></textarea>
+        </div>
+
+        <div class="form-group">
+            <label for="audioUrl">Audio File URL (MP3)</label>
+            <input type="url" id="audioUrl" placeholder="https://example.com/sample.mp3">
+        </div>
+
+        <button onclick="testEndpoint()">Test Endpoint</button>
+
+        <div id="response"></div>
+    </div>
+
+    <script>
+        async function generateAudio() {
+            const text = document.getElementById('murfText').value;
+            const murfKey = document.getElementById('murfKey').value;
+            const statusDiv = document.getElementById('genStatus');
+            const audioUrlInput = document.getElementById('audioUrl');
+
+            if (!text || !murfKey) {
+                alert("Please enter Text and Murf API Key");
+                return;
+            }
+
+            statusDiv.innerHTML = "Generating...";
+
+            try {
+                const response = await fetch('/generate', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        text: text,
+                        murf_api_key: murfKey
+                    })
+                });
+
+                const data = await response.json();
+
+                if (response.ok) {
+                    statusDiv.innerHTML = "Generated! URL copied to input below.";
+                    statusDiv.className = 'success';
+                    audioUrlInput.value = data.audio_url;
+                } else {
+                    statusDiv.innerHTML = "Error: " + (data.detail || JSON.stringify(data));
+                    statusDiv.className = 'error';
+                }
+            } catch (e) {
+                statusDiv.innerHTML = "Error: " + e.message;
+                statusDiv.className = 'error';
+            }
+        }
+
+        async function testEndpoint() {
+            const apiUrl = document.getElementById('apiUrl').value;
+            const apiKey = document.getElementById('apiKey').value;
+            const message = document.getElementById('message').value;
+            const audioUrl = document.getElementById('audioUrl').value;
+            const responseDiv = document.getElementById('response');
+
+            responseDiv.style.display = 'block';
+            responseDiv.innerHTML = 'Sending request...';
+            responseDiv.className = '';
+
+            const formData = new FormData();
+            formData.append('message', message);
+            formData.append('audio_url', audioUrl);
+
+            // Note: We are strictly testing audio_url flow as per tool description. 
+            // If we supported file upload input, we would append it here.
+
+            try {
+                const response = await fetch(apiUrl, {
+                    method: 'POST',
+                    headers: {
+                        'x-api-key': apiKey
+                    },
+                    body: formData
+                });
+
+                const data = await response.json();
+
+                if (response.ok) {
+                    responseDiv.innerHTML = '<strong>Success!</strong>\n' + JSON.stringify(data, null, 2);
+                    responseDiv.className = 'success';
+                } else {
+                    responseDiv.innerHTML = '<strong>Error ' + response.status + ':</strong>\n' + JSON.stringify(data, null, 2);
+                    responseDiv.className = 'error';
+                }
+            } catch (error) {
+                responseDiv.innerHTML = '<strong>Network Error:</strong> ' + error.message;
+                responseDiv.className = 'error';
+            }
+        }
+    </script>
+</body>
+
+</html>

test_api.py

@@ -0,0 +1,49 @@
+import requests
+import os
+
+# Configuration
+BASE_URL = "http://127.0.0.1:8000"
+API_KEY = "my_secret_key_123"
+TEST_FILE = "test_audio.mp3"
+
+def create_dummy_mp3():
+    with open(TEST_FILE, "wb") as f:
+        f.write(b"\x00" * 1024) # 1KB of dummy data
+
+def test_auth_failure():
+    print("Testing Authentication Failure...")
+    files = {'file': open(TEST_FILE, 'rb')}
+    response = requests.post(f"{BASE_URL}/detect", files=files, headers={"x-api-key": "wrong_key"})
+    if response.status_code == 401:
+        print("PASS: Auth failure handled correctly.")
+    else:
+        print(f"FAIL: Expected 401, got {response.status_code}")
+
+def test_success_flow():
+    print("Testing Success Flow...")
+    files = {'file': open(TEST_FILE, 'rb')}
+    response = requests.post(f"{BASE_URL}/detect", files=files, headers={"x-api-key": API_KEY})
+    
+    if response.status_code == 200:
+        data = response.json()
+        print("PASS: Request successful.")
+        print("Response:", data)
+        
+        # Verify structure
+        if "analysis" in data and "is_human" in data["analysis"]:
+            print("PASS: JSON structure validated.")
+        else:
+            print("FAIL: JSON structure incorrect.")
+    else:
+        print(f"FAIL: Expected 200, got {response.status_code}. Text: {response.text}")
+
+if __name__ == "__main__":
+    create_dummy_mp3()
+    try:
+        test_auth_failure()
+        test_success_flow()
+    except Exception as e:
+        print(f"An error occurred: {e}")
+    finally:
+        if os.path.exists(TEST_FILE):
+            os.remove(TEST_FILE)

test_details.py

@@ -0,0 +1,24 @@
+import requests
+
+def test_api_with_url():
+    url = "http://127.0.0.1:8000/detect"
+    headers = {"x-api-key": "my_secret_key_123"}
+    data = {
+        "message": "Testing audio URL",
+        "audio_url": "https://www.soundhelix.com/examples/mp3/SoundHelix-Song-1.mp3" # A public sample
+    }
+    
+    print("Testing with audio_url...")
+    try:
+        response = requests.post(url, headers=headers, data=data)
+        if response.status_code == 200:
+            print("PASS: Request successful")
+            print(response.json())
+        else:
+            print(f"FAIL: Status {response.status_code}")
+            print(response.text)
+    except Exception as e:
+        print(f"FAIL: {e}")
+
+if __name__ == "__main__":
+    test_api_with_url()

test_murf.py

@@ -0,0 +1,25 @@
+import requests
+
+def test_generate_endpoint():
+    url = "http://127.0.0.1:8000/generate"
+    payload = {
+        "text": "Hello",
+        "murf_api_key": "dummy_key",
+        "voice_id": "en-US-marcus"
+    }
+    
+    print("Testing /generate endpoint...")
+    response = requests.post(url, json=payload)
+    
+    # We expect 400 because the key is dummy, but this proves the endpoint exists and calls Murf
+    if response.status_code == 400:
+        print("PASS: Endpoint exists and returned 400 as expected (Invalid Key).")
+        print("Response:", response.json())
+    elif response.status_code == 200:
+        print("FAIL: Unexpected Success with dummy key?")
+    else:
+        print(f"FAIL: Status {response.status_code}")
+        print(response.text)
+
+if __name__ == "__main__":
+    test_generate_endpoint()

verify_murf_key.py

@@ -0,0 +1,29 @@
+import requests
+
+def test_generate_real():
+    url = "http://127.0.0.1:8000/generate"
+    # Key provided by user
+    api_key = "ap2_b71da4b1-5155-47a2-b522-431fe5cb728d"
+    
+    payload = {
+        "text": "Hello, verification successful.",
+        "murf_api_key": api_key,
+        "voice_id": "en-US-marcus"
+    }
+    
+    print("Testing /generate with PROVIDED key...")
+    try:
+        response = requests.post(url, json=payload)
+        
+        if response.status_code == 200:
+            data = response.json()
+            print("PASS: Audio Generated Successfully!")
+            print(f"Audio URL: {data.get('audio_url')}")
+        else:
+            print(f"FAIL: Status {response.status_code}")
+            print(response.text)
+    except Exception as e:
+        print(f"FAIL: {e}")
+
+if __name__ == "__main__":
+    test_generate_real()