benoit/Audio-Classifier
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'Backend'

Browse Source 
Merge Backend
This commit is contained in:
Benoit
2025-12-23 13:08:43 +01:00
parent 7ce2b70a8c df781fb605
commit e3d85f4775
35 changed files with 1252 additions and 2906 deletions
Download Patch File Download Diff File Expand all files Collapse all files

264
.claude-todo.md
View File

@@ -1,264 +0,0 @@
# Audio Classifier - TODO Mise à Jour (6 décembre 2024)
## ✅ Ce qui est FAIT (État actuel du projet)
### Infrastructure
- ✅ Structure complète backend + frontend
- ✅ Docker Compose avec PostgreSQL + pgvector
- ✅ Backend Dockerfile (Python 3.9, émulation x86_64 pour Essentia)
- ✅ Frontend Dockerfile
- ✅ Containers en production (running actuellement)
- ✅ .env et .env.example configurés
- ✅ Modèles Essentia téléchargés (genre, mood, instrument)
### Backend (Python/FastAPI)
- ✅ Structure complète src/
- ✅ Modèles SQLAlchemy (schema.py) avec AudioTrack
- ✅ Migrations Alembic fonctionnelles
- ✅ CRUD complet (crud.py)
- ✅ API FastAPI (main.py)
- ✅ Routes implémentées :
- ✅ /api/tracks (GET, DELETE)
- ✅ /api/search
- ✅ /api/audio (stream, download, waveform)
- ✅ /api/analyze
- ✅ /api/similar
- ✅ /api/stats
- ✅ Core modules :
- ✅ audio_processor.py (Librosa)
- ✅ essentia_classifier.py (modèles genre/mood/instruments)
- ✅ analyzer.py (orchestrateur)
- ✅ file_scanner.py
- ✅ waveform_generator.py
- ✅ Utils (config, logging, validators)
- ✅ CLI scanner fonctionnel
### Frontend (Next.js 14)
- ✅ Structure Next.js 14 avec TypeScript
- ✅ TailwindCSS + shadcn/ui setup
- ✅ API client (lib/api.ts)
- ✅ Types TypeScript (lib/types.ts)
- ✅ QueryProvider configuré
- ✅ Layout principal
- ✅ Page principale (app/page.tsx)
### Documentation
- ✅ README.md complet
- ✅ QUICKSTART.md
- ✅ SETUP.md
- ✅ STATUS.md
- ✅ COMMANDES.md
- ✅ DOCKER.md
- ✅ ESSENTIA.md
- ✅ CORRECTIONS.md
- ✅ RESUME.md
---
## 🔧 Ce qui reste À FAIRE
### Phase 1: Finaliser Docker pour Mac ARM
#### 1.1 Docker Build Optimization
- [ ] **Finir le build Docker backend** (actuellement timeout à 10min)
- Build en cours mais très lent (émulation x86_64)
- Options :
- [ ] Option A : Augmenter timeout et laisser finir (15-20 min estimé)
- [ ] Option B : Build natif ARM64 en compilant Essentia depuis sources
- [ ] Option C : Utiliser image multi-arch existante (mgoltzsche/essentia-container)
- [ ] Tester le container backend une fois buildé
- [ ] Vérifier que Essentia fonctionne correctement dans le container
- [ ] Documenter temps de build et performances
#### 1.2 Docker Compose Validation
- [ ] Tester docker-compose up complet
- [ ] Vérifier connectivité DB ↔ Backend
- [ ] Vérifier connectivité Frontend ↔ Backend
- [ ] Tester les 3 services ensemble
---
### Phase 2: Frontend Components (PRIORITAIRE)
Le frontend a la structure mais manque les composants UI. **C'est la priorité #1.**
#### 2.1 Composants de base manquants
- [ ] `components/SearchBar.tsx`
- [ ] `components/FilterPanel.tsx`
- [ ] `components/TrackCard.tsx`
- [ ] `components/TrackDetails.tsx` (Modal)
- [ ] `components/AudioPlayer.tsx`
- [ ] `components/WaveformDisplay.tsx`
- [ ] `components/BatchScanner.tsx`
- [ ] `components/SimilarTracks.tsx`
#### 2.2 Hooks manquants
- [ ] `hooks/useSearch.ts` (recherche avec debounce)
- [ ] `hooks/useTracks.ts` (fetch + pagination)
- [ ] `hooks/useAudioPlayer.ts` (state audio player)
#### 2.3 Pages manquantes
- [ ] `app/tracks/[id]/page.tsx` (page détail track)
#### 2.4 Installation shadcn components
- [ ] Installer composants shadcn manquants :
```bash
npx shadcn@latest add button input slider select card dialog badge progress toast dropdown-menu tabs
```
---
### Phase 3: Tests & Validation
#### 3.1 Tests Backend
- [ ] Tester analyse d'un fichier audio réel
- [ ] Tester scanner CLI sur un dossier
- [ ] Vérifier classifications Essentia (genre/mood)
- [ ] Tester endpoints API avec curl/Postman
- [ ] Vérifier waveform generation
#### 3.2 Tests Frontend
- [ ] Tester affichage liste tracks
- [ ] Tester recherche et filtres
- [ ] Tester lecture audio
- [ ] Tester waveform display
- [ ] Tester scanner de dossier
- [ ] Tester navigation
#### 3.3 Tests End-to-End
- [ ] Flow complet : Scanner dossier → Voir résultats → Jouer track → Chercher similaires
- [ ] Tester avec bibliothèque réelle (>100 fichiers)
- [ ] Vérifier performances
---
### Phase 4: Optimisations & Polish
#### 4.1 Performance
- [ ] Optimiser temps de build Docker (si nécessaire)
- [ ] Cache waveform peaks
- [ ] Optimiser requêtes DB (indexes)
- [ ] Lazy loading tracks (pagination infinie)
#### 4.2 UX
- [ ] Loading skeletons
- [ ] Error boundaries
- [ ] Toast notifications
- [ ] Keyboard shortcuts (espace = play/pause)
- [ ] Dark mode support
#### 4.3 Backend improvements
- [ ] Rate limiting API
- [ ] Structured logging
- [ ] Error handling middleware
- [ ] Health checks détaillés
---
### Phase 5: Features additionnelles (Nice-to-have)
#### 5.1 Features manquantes du plan original
- [ ] Batch export (CSV/JSON)
- [ ] Playlists
- [ ] Duplicate detection
- [ ] Tag editing
- [ ] Visualisations avancées (spectrogram)
#### 5.2 Embeddings CLAP (Future)
- [ ] Intégration CLAP pour semantic search
- [ ] Utiliser pgvector pour similarity search
- [ ] API endpoint pour recherche sémantique
#### 5.3 Multi-user (Future)
- [ ] Authentication JWT
- [ ] User management
- [ ] Permissions
---
## 🎯 ROADMAP RECOMMANDÉE
### Sprint 1 (Cette semaine) - MINIMUM VIABLE PRODUCT
1. ✅ ~~Finaliser Docker setup~~
2. **Créer composants frontend de base** (SearchBar, TrackCard, AudioPlayer)
3. **Créer hooks frontend** (useTracks, useAudioPlayer)
4. **Page principale fonctionnelle** avec liste + lecture
5. **Tester flow complet** avec fichiers audio réels
### Sprint 2 (Semaine prochaine) - FEATURES COMPLÈTES
1. Composants avancés (FilterPanel, BatchScanner, SimilarTracks)
2. Page détail track
3. Optimisations performance
4. Polish UX (loading states, errors, toasts)
### Sprint 3 (Après) - POLISH & EXTRAS
1. Dark mode
2. Keyboard shortcuts
3. Export data
4. Documentation finale
---
## 📝 Notes Importantes
### Docker Build sur Mac ARM
- **Problème actuel** : Build très lent (10+ min) car Essentia nécessite émulation x86_64
- **Solution actuelle** : `FROM --platform=linux/amd64 python:3.9-slim` dans Dockerfile
- **Performance** : Runtime sera aussi émulé (plus lent mais fonctionnel)
- **Alternative** : Compiler Essentia pour ARM64 (complexe, long)
### Priorités
1. **Frontend components** → Rendre l'app utilisable
2. **Tests avec vraie data** → Valider que tout fonctionne
3. **Polish UX** → Rendre l'app agréable
### État actuel
- ✅ Backend 95% complet et fonctionnel
- ⚠️ Frontend 30% complet (structure ok, UI manquante)
- ⚠️ Docker 90% (backend build en cours)
- ✅ Documentation excellente
---
## 🚀 Commandes Utiles
### Docker
```bash
# Build (peut prendre 15-20 min sur Mac ARM)
docker-compose build
# Démarrer
docker-compose up
# Logs
docker-compose logs -f backend
# Scanner un dossier
docker exec audio_classifier_api python -m src.cli.scanner /music --recursive
```
### Dev Local
```bash
# Backend
cd backend
pip install -r requirements.txt
uvicorn src.api.main:app --reload
# Frontend
cd frontend
npm install
npm run dev
```
---
## ✨ Prochaine étape immédiate
**CRÉER LES COMPOSANTS FRONTEND** pour avoir une interface utilisable.
Ordre suggéré :
1. TrackCard (afficher les tracks)
2. AudioPlayer (jouer les tracks)
3. SearchBar + FilterPanel (recherche)
4. BatchScanner (scanner des dossiers)
5. TrackDetails + SimilarTracks (features avancées)

3
.claude/settings.local.json
View File

@@ -9,7 +9,8 @@
"Bash(bash scripts/download-essentia-models.sh:*)", "Bash(bash scripts/download-essentia-models.sh:*)",
"Bash(curl:*)", "Bash(curl:*)",
"Bash(docker logs:*)", "Bash(docker logs:*)",
"Bash(docker exec:*)" "Bash(docker exec:*)",
"Bash(ls:*)"
] ]
} }
} }

317
COMMANDES.md
View File

@@ -1,317 +0,0 @@
# 📝 Commandes Essentielles - Audio Classifier
## 🚀 Démarrage
### Lancer tous les services
```bash
cd "/Users/benoit/Documents/code/Audio Classifier"
docker-compose -f docker-compose.dev.yml up -d
```
### Vérifier le statut
```bash
docker-compose -f docker-compose.dev.yml ps
docker-compose -f docker-compose.dev.yml logs -f backend
```
### Lancer le frontend
```bash
cd frontend
npm run dev
```
## 🔍 Vérifications
### Health check
```bash
curl http://localhost:8001/health
```
### Stats base de données
```bash
curl http://localhost:8001/api/stats | python3 -m json.tool
```
### Liste des pistes
```bash
curl http://localhost:8001/api/tracks?limit=5 | python3 -m json.tool
```
## 🎵 Analyse audio
### Analyser un dossier
```bash
curl -X POST http://localhost:8001/api/analyze/folder \
-H "Content-Type: application/json" \
-d '{
"path": "/audio",
"recursive": true
}'
```
Retourne un `job_id`
### Vérifier la progression
```bash
# Remplacer JOB_ID par l'ID retourné
curl http://localhost:8001/api/analyze/status/JOB_ID | python3 -m json.tool
```
## 🔎 Recherche
### Recherche textuelle
```bash
curl "http://localhost:8001/api/search?q=jazz&limit=10" | python3 -m json.tool
```
### Filtrer par BPM
```bash
curl "http://localhost:8001/api/tracks?bpm_min=120&bpm_max=140&limit=20" | python3 -m json.tool
```
### Filtrer par genre
```bash
curl "http://localhost:8001/api/tracks?genre=electronic&limit=10" | python3 -m json.tool
```
### Filtrer par énergie
```bash
curl "http://localhost:8001/api/tracks?energy_min=0.7&limit=10" | python3 -m json.tool
```
## 🎧 Audio
### Stream (dans navigateur)
```bash
# Récupérer un track_id d'abord
TRACK_ID=$(curl -s "http://localhost:8001/api/tracks?limit=1" | python3 -c "import sys, json; print(json.load(sys.stdin)['tracks'][0]['id'])")
# Ouvrir dans navigateur
open "http://localhost:8001/api/audio/stream/$TRACK_ID"
```
### Download
```bash
curl -o music.mp3 "http://localhost:8001/api/audio/download/$TRACK_ID"
```
### Waveform data
```bash
curl "http://localhost:8001/api/audio/waveform/$TRACK_ID" | python3 -m json.tool
```
## 🗄️ Base de données
### Connexion psql
```bash
docker exec -it audio_classifier_db psql -U audio_user -d audio_classifier
```
### Queries utiles
```sql
-- Nombre total de pistes
SELECT COUNT(*) FROM audio_tracks;
-- 10 dernières pistes analysées
SELECT filename, tempo_bpm, key, genre_primary, mood_primary, analyzed_at
FROM audio_tracks
ORDER BY analyzed_at DESC
LIMIT 10;
-- Pistes par genre
SELECT genre_primary, COUNT(*)
FROM audio_tracks
WHERE genre_primary IS NOT NULL
GROUP BY genre_primary
ORDER BY COUNT(*) DESC;
-- Pistes rapides (> 140 BPM)
SELECT filename, tempo_bpm
FROM audio_tracks
WHERE tempo_bpm > 140
ORDER BY tempo_bpm DESC;
```
### Migrations
```bash
# Appliquer les migrations
docker exec audio_classifier_api alembic upgrade head
# Vérifier la version
docker exec audio_classifier_api alembic current
# Historique
docker exec audio_classifier_api alembic history
```
## 🛠️ Gestion services
### Arrêter
```bash
docker-compose -f docker-compose.dev.yml stop
```
### Redémarrer
```bash
docker-compose -f docker-compose.dev.yml restart
```
### Redémarrer uniquement le backend
```bash
docker-compose -f docker-compose.dev.yml restart backend
```
### Logs
```bash
# Tous les services
docker-compose -f docker-compose.dev.yml logs -f
# Backend seulement
docker-compose -f docker-compose.dev.yml logs -f backend
# PostgreSQL
docker-compose -f docker-compose.dev.yml logs -f postgres
```
### Rebuild
```bash
docker-compose -f docker-compose.dev.yml build backend
docker-compose -f docker-compose.dev.yml up -d
```
### Supprimer tout (⚠️ perd les données)
```bash
docker-compose -f docker-compose.dev.yml down -v
```
## 🔧 Configuration
### Modifier le dossier audio
```bash
# Éditer .env
nano .env
# Changer:
AUDIO_LIBRARY_PATH=/nouveau/chemin/vers/audio
# Redémarrer
docker-compose -f docker-compose.dev.yml restart backend
```
### Changer le nombre de workers
```bash
# Éditer .env
ANALYSIS_NUM_WORKERS=8
# Redémarrer
docker-compose -f docker-compose.dev.yml restart backend
```
## 📊 Statistiques
### Stats globales
```bash
curl http://localhost:8001/api/stats | python3 -m json.tool
```
### Nombre de pistes
```bash
curl -s http://localhost:8001/api/stats | python3 -c "import sys, json; print(f\"Total tracks: {json.load(sys.stdin)['total_tracks']}\")"
```
## 🧪 Tests
### Test health check
```bash
curl -f http://localhost:8001/health && echo "✅ OK" || echo "❌ FAIL"
```
### Test connexion DB
```bash
docker exec audio_classifier_db pg_isready -U audio_user && echo "✅ DB OK" || echo "❌ DB FAIL"
```
### Test frontend
```bash
curl -f http://localhost:3000 && echo "✅ Frontend OK" || echo "❌ Frontend FAIL"
```
## 📖 Documentation
### API interactive
```bash
open http://localhost:8001/docs
```
### Frontend
```bash
open http://localhost:3000
```
## 🆘 Debug
### Voir les variables d'environnement
```bash
docker exec audio_classifier_api env | grep -E "DATABASE_URL|CORS|ANALYSIS"
```
### Vérifier les ports
```bash
lsof -i :8001 # Backend
lsof -i :5433 # PostgreSQL
lsof -i :3000 # Frontend
```
### Espace disque Docker
```bash
docker system df
docker system prune # Nettoyer
```
## 🎯 Workflows courants
### Analyser une nouvelle bibliothèque
```bash
# 1. Configurer le chemin
echo 'AUDIO_LIBRARY_PATH=/path/to/music' >> .env
# 2. Redémarrer
docker-compose -f docker-compose.dev.yml restart backend
# 3. Lancer l'analyse
curl -X POST http://localhost:8001/api/analyze/folder \
-H "Content-Type: application/json" \
-d '{"path": "/audio", "recursive": true}'
# 4. Suivre la progression (récupérer job_id d'abord)
watch -n 2 "curl -s http://localhost:8001/api/analyze/status/JOB_ID | python3 -m json.tool"
```
### Rechercher et écouter
```bash
# 1. Rechercher
curl "http://localhost:8001/api/search?q=upbeat" | python3 -m json.tool
# 2. Copier un track_id
# 3. Écouter
open "http://localhost:8001/api/audio/stream/TRACK_ID"
```
### Export des résultats
```bash
# Export JSON toutes les pistes
curl "http://localhost:8001/api/tracks?limit=10000" > tracks.json
# Export CSV (simple)
curl -s "http://localhost:8001/api/tracks?limit=10000" | \
python3 -c "import sys, json, csv; data = json.load(sys.stdin)['tracks']; writer = csv.DictWriter(sys.stdout, fieldnames=['filename', 'tempo_bpm', 'key', 'genre_primary']); writer.writeheader(); [writer.writerow({k: track.get(k) or track['features'].get(k) or track['classification']['genre'].get('primary') for k in ['filename', 'tempo_bpm', 'key', 'genre_primary']}) for track in data]" > tracks.csv
```
---
**Rappel des URLs** :
- Backend API : http://localhost:8001
- API Docs : http://localhost:8001/docs
- Frontend : http://localhost:3000
- PostgreSQL : localhost:5433

137
CORRECTIONS.md
View File

@@ -1,137 +0,0 @@
# 🔧 Corrections Appliquées
## Problème résolu : Build Docker
### Problème initial
```
ERROR: Could not find a version that satisfies the requirement essentia-tensorflow==2.1b6.dev1110
ERROR: No matching distribution found for essentia-tensorflow==2.1b6.dev1110
```
### Cause
La version `essentia-tensorflow==2.1b6.dev1110` spécifiée dans `requirements.txt` n'existe pas sur PyPI. C'était une version de développement qui n'a jamais été publiée.
### Solution appliquée
✅ **Correction du `requirements.txt`** :
- Suppression de la ligne `essentia-tensorflow==2.1b6.dev1110`
- Ajout de commentaires expliquant comment installer Essentia manuellement si besoin
- Le système fonctionne maintenant **sans Essentia** en utilisant uniquement Librosa
✅ **Mise à jour des ports dans `docker-compose.yml`** :
- PostgreSQL : `5433` (au lieu de 5432, conflit avec votre instance existante)
- Backend : `8001` (au lieu de 8000, conflit avec autre service)
✅ **Build Docker fonctionnel** :
```bash
docker-compose build backend
# → Successfully installed!
```
## Fichiers modifiés
### 1. `backend/requirements.txt`
**Avant** :
```txt
essentia-tensorflow==2.1b6.dev1110
```
**Après** :
```txt
# Optional: Essentia for genre/mood/instrument classification
# Note: essentia-tensorflow not available on PyPI for all platforms
# Uncomment if you can install it (Linux x86_64 only):
# essentia==2.1b6.dev1110
# For manual installation: pip install essentia
# Or build from source: https://github.com/MTG/essentia
```
### 2. `docker-compose.yml`
**Avant** :
```yaml
ports:
- "5432:5432" # PostgreSQL
- "8000:8000" # Backend
```
**Après** :
```yaml
ports:
- "5433:5432" # PostgreSQL (évite conflit)
- "8001:8000" # Backend (évite conflit)
```
### 3. Fichier `extra_metadata` dans `schema.py`
**Problème** : `metadata` est un nom réservé par SQLAlchemy.
**Correction** : Renommé en `extra_metadata` dans :
- `backend/src/models/schema.py`
- `backend/src/models/crud.py`
## Impact
### ✅ Ce qui fonctionne maintenant
- Build Docker complet sans erreurs
- Backend opérationnel sur port 8001
- PostgreSQL sur port 5433
- Tous les endpoints API fonctionnels
- Extraction de features audio (Librosa)
### ⚠️ Ce qui n'est pas disponible
- Classification automatique des genres (Essentia)
- Classification des moods/ambiances (Essentia)
- Détection des instruments (Essentia)
**Mais** : Ces fonctionnalités ne sont **pas nécessaires** pour 95% des cas d'usage !
## Alternatives pour la classification
Si vous avez vraiment besoin de classification automatique, voir [ESSENTIA.md](ESSENTIA.md) pour :
1. **CLAP** (Contrastive Language-Audio Pretraining) - Recommandé
2. **Panns** (Pre-trained Audio Neural Networks) - Stable
3. **Hugging Face Transformers** - Moderne
Ces solutions sont **plus récentes** et **mieux maintenues** qu'Essentia.
## Vérification
### Test du build
```bash
docker-compose build backend
# → ✅ Successfully built
```
### Test du démarrage
```bash
docker-compose up -d
# → ✅ Services started
curl http://localhost:8001/health
# → ✅ {"status":"healthy"}
```
### Test de l'API
```bash
curl http://localhost:8001/api/stats
# → ✅ {"total_tracks":0,"genres":[],...}
```
## Commandes mises à jour
Toutes les commandes dans la documentation utilisent maintenant les bons ports :
- **Backend API** : http://localhost:8001 (au lieu de 8000)
- **PostgreSQL** : localhost:5433 (au lieu de 5432)
- **Frontend** : http://localhost:3000 (inchangé)
## Conclusion
Le projet est maintenant **100% fonctionnel** avec :
- ✅ Build Docker sans erreurs
- ✅ Toutes les dépendances installées
- ✅ Services opérationnels
- ✅ API complète fonctionnelle
- ✅ Extraction audio Librosa
**Pas besoin d'Essentia** pour utiliser le système efficacement ! 🎵

196
DEMARRAGE.md
View File

@@ -1,196 +0,0 @@
# 🚀 Démarrage - Audio Classifier
## ✅ Statut
Le projet est configuré et prêt à fonctionner !
## Configuration actuelle
- **Backend API** : http://localhost:8001
- **Base de données** : PostgreSQL sur port 5433
- **Frontend** : À lancer sur port 3000
## 1. Services Docker (Déjà lancés)
```bash
cd "/Users/benoit/Documents/code/Audio Classifier"
# Vérifier que les services tournent
docker-compose -f docker-compose.dev.yml ps
# Logs du backend
docker-compose -f docker-compose.dev.yml logs -f backend
```
## 2. Tester le backend
```bash
# Health check
curl http://localhost:8001/health
# Documentation interactive
open http://localhost:8001/docs
```
## 3. Lancer le frontend
```bash
cd frontend
# Si pas encore fait
npm install
# Créer .env.local
cat > .env.local << EOF
NEXT_PUBLIC_API_URL=http://localhost:8001
EOF
# Lancer
npm run dev
```
Frontend accessible sur : **http://localhost:3000**
## 4. Analyser votre bibliothèque audio
### Option A : Via l'API
```bash
# Analyser un dossier
curl -X POST http://localhost:8001/api/analyze/folder \
-H "Content-Type: application/json" \
-d '{
"path": "/audio",
"recursive": true
}'
# Note: "/audio" correspond au montage dans le conteneur
# Pour analyser vos fichiers, mettre à jour AUDIO_LIBRARY_PATH dans .env
```
### Option B : Depuis votre machine (sans Essentia)
Le système fonctionne actuellement **sans les modèles Essentia** pour simplifier le déploiement.
**Fonctionnalités disponibles** :
- ✅ Extraction tempo (BPM)
- ✅ Détection tonalité
- ✅ Features spectrales (energy, danceability, valence)
- ✅ Signature rythmique
- ❌ Classification genre/mood/instruments (nécessite Essentia)
**Pour activer Essentia** (optionnel) :
1. Télécharger les modèles :
```bash
./scripts/download-essentia-models.sh
```
2. Reconstruire avec Dockerfile complet :
```bash
# Éditer docker-compose.dev.yml
# Changer: dockerfile: Dockerfile.minimal
# En: dockerfile: Dockerfile
docker-compose -f docker-compose.dev.yml build backend
docker-compose -f docker-compose.dev.yml up -d
```
## 5. Commandes utiles
### Gérer les services
```bash
# Arrêter
docker-compose -f docker-compose.dev.yml stop
# Redémarrer
docker-compose -f docker-compose.dev.yml restart
# Tout supprimer (⚠️ perd les données DB)
docker-compose -f docker-compose.dev.yml down -v
```
### Requêtes API
```bash
# Lister les pistes
curl http://localhost:8001/api/tracks?limit=10
# Recherche
curl "http://localhost:8001/api/search?q=test&limit=10"
# Stats
curl http://localhost:8001/api/stats
# Stream audio (remplacer TRACK_ID)
open http://localhost:8001/api/audio/stream/TRACK_ID
# Download audio
curl -O http://localhost:8001/api/audio/download/TRACK_ID
```
## 6. Configuration avancée
### Changer le dossier audio à analyser
Éditer `.env` :
```env
AUDIO_LIBRARY_PATH=/Users/benoit/Music
```
Puis redémarrer :
```bash
docker-compose -f docker-compose.dev.yml restart backend
```
### Accéder à la base de données
```bash
# Connexion psql
docker exec -it audio_classifier_db psql -U audio_user -d audio_classifier
# Queries utiles
\dt -- Liste des tables
SELECT COUNT(*) FROM audio_tracks;
SELECT filename, tempo_bpm, key FROM audio_tracks LIMIT 5;
```
## 🐛 Problèmes courants
### Backend ne démarre pas
```bash
docker-compose -f docker-compose.dev.yml logs backend
```
### Port déjà utilisé
Les ports ont été changés pour éviter les conflits :
- PostgreSQL : **5433** (au lieu de 5432)
- Backend : **8001** (au lieu de 8000)
### Frontend ne se connecte pas
Vérifier `.env.local` dans le dossier `frontend` :
```env
NEXT_PUBLIC_API_URL=http://localhost:8001
```
## 📚 Documentation
- [README.md](README.md) - Vue d'ensemble
- [SETUP.md](SETUP.md) - Guide complet
- http://localhost:8001/docs - API interactive
## 🎵 Prochaines étapes
1. **Analyser vos fichiers** : Utiliser l'API `/api/analyze/folder`
2. **Explorer le frontend** : Naviguer dans les pistes
3. **Tester la recherche** : Filtrer par BPM, etc.
4. **Activer Essentia** (optionnel) : Pour genre/mood/instruments
Bon classement ! 🎶

322
DEPLOYMENT.md Normal file
View File

@@ -0,0 +1,322 @@
# Déploiement Audio Classifier
## 🚀 Déploiement Autonome
Le système est **100% autonome** - aucune action manuelle requise ! Les modèles Essentia sont intégrés dans l'image Docker.
### Prérequis
- Docker + Docker Compose
- 2 GB RAM minimum
- Port 3000 (frontend) et 8001 (backend) disponibles
### Démarrage Rapide
1. **Cloner le projet** :
```bash
git clone <votre-repo>
cd Audio-Classifier
```
2. **Configurer le chemin audio** (optionnel) :
```bash
# Créer un fichier .env
echo "AUDIO_LIBRARY_PATH=/chemin/vers/votre/musique" > .env
```
3. **Démarrer** :
```bash
docker-compose up -d
```
4. **Accéder à l'interface** :
- Frontend : http://localhost:3000
- API : http://localhost:8001
- Docs API : http://localhost:8001/docs
C'est tout ! 🎉
### Premier Scan
1. Ouvrir http://localhost:3000
2. Cliquer sur le bouton **"Rescan"** dans le header
3. Attendre que le scan se termine (progression affichée)
4. Profiter !
## 📦 Ce qui est inclus dans l'image
✅ **Modèles Essentia** (28 MB) :
- `discogs-effnet-bs64-1.pb` (18 MB) - Embedding model
- `genre_discogs400-discogs-effnet-1.pb` (2 MB) - Genre classifier
- `mtg_jamendo_moodtheme-discogs-effnet-1.pb` (2.7 MB) - Mood classifier
- `mtg_jamendo_instrument-discogs-effnet-1.pb` (2.6 MB) - Instrument classifier
✅ **Dépendances Python** :
- FastAPI, Uvicorn
- Essentia-TensorFlow
- Librosa, SQLAlchemy
- FFmpeg (pour transcodage)
✅ **Base de données** :
- PostgreSQL avec pgvector
- Migrations Alembic auto-appliquées
## ⚙️ Configuration
### Variables d'environnement (.env)
```bash
# Audio Library
AUDIO_LIBRARY_PATH=/chemin/vers/musique # Défaut: ./audio_samples
# Database
POSTGRES_USER=audio_user
POSTGRES_PASSWORD=audio_password
POSTGRES_DB=audio_classifier
# CORS (pour déploiement distant)
CORS_ORIGINS=http://localhost:3000,http://votre-domaine.com
```
### Ports
Par défaut :
- Frontend : `3000`
- Backend API : `8001`
- PostgreSQL : `5433` (mapping host)
Pour changer :
```yaml
# Dans docker-compose.yml
services:
backend:
ports:
- "VOTRE_PORT:8000"
```
## 🔄 Mise à jour
```bash
# Arrêter les containers
docker-compose down
# Pull les dernières modifications
git pull
# Rebuild et redémarrer
docker-compose up -d --build
```
## 📊 Monitoring
### Logs en temps réel
```bash
# Tous les services
docker-compose logs -f
# Backend uniquement
docker-compose logs -f backend
# Frontend uniquement
docker-compose logs -f frontend
```
### Statut des containers
```bash
docker-compose ps
```
### Santé de l'API
```bash
curl http://localhost:8001/health
```
## 🗄️ Gestion de la base de données
### Backup
```bash
docker-compose exec postgres pg_dump -U audio_user audio_classifier > backup.sql
```
### Restore
```bash
docker-compose exec -T postgres psql -U audio_user audio_classifier < backup.sql
```
### Reset complet
```bash
docker-compose down -v # ATTENTION : supprime toutes les données !
docker-compose up -d
```
## 🎵 Scan de bibliothèque
### Via l'interface web
Cliquez sur **"Rescan"** dans le header.
### Via l'API
```bash
curl -X POST http://localhost:8001/api/library/scan
```
### Via CLI (dans le container)
```bash
docker-compose exec backend python -m src.cli.scanner /audio
```
### Statut du scan
```bash
curl http://localhost:8001/api/library/scan/status
```
## 📁 Structure des fichiers générés
Lors du scan, deux dossiers sont créés automatiquement :
```
/votre/musique/
├── fichier1.mp3
├── fichier2.flac
├── transcoded/ # MP3 128kbps pour streaming
│ ├── fichier1.mp3
│ └── fichier2.mp3
└── waveforms/ # JSON pré-calculés
├── fichier1.waveform.json
└── fichier2.waveform.json
```
## 🚢 Déploiement Production
### Sur un serveur distant
1. **Installer Docker** sur le serveur
2. **Cloner et configurer** :
```bash
git clone <votre-repo>
cd Audio-Classifier
```
3. **Configurer .env** :
```bash
# Chemin vers musique
AUDIO_LIBRARY_PATH=/mnt/musique
# Domaine public
CORS_ORIGINS=http://votre-domaine.com,https://votre-domaine.com
# Credentials BDD (sécurisés !)
POSTGRES_PASSWORD=motdepasse_fort_aleatoire
```
4. **Démarrer** :
```bash
docker-compose up -d
```
5. **Configurer reverse proxy** (Nginx/Caddy) :
```nginx
# Exemple Nginx
server {
server_name votre-domaine.com;
location / {
proxy_pass http://localhost:3000;
}
location /api/ {
proxy_pass http://localhost:8001/api/;
}
}
```
### Avec Docker Hub
1. **Tag et push** :
```bash
docker tag audio-classifier-backend:latest votrecompte/audio-classifier-backend:latest
docker push votrecompte/audio-classifier-backend:latest
```
2. **Sur le serveur** :
```yaml
# docker-compose.yml
services:
backend:
image: votrecompte/audio-classifier-backend:latest
# ... reste de la config
```
## 🔒 Sécurité
### Recommandations
✅ Changer les mots de passe par défaut
✅ Utiliser HTTPS en production (Let's Encrypt)
✅ Restreindre CORS_ORIGINS aux domaines autorisés
✅ Ne pas exposer PostgreSQL publiquement
✅ Backups réguliers de la BDD
### Firewall
```bash
# Autoriser uniquement ports nécessaires
ufw allow 80/tcp # HTTP
ufw allow 443/tcp # HTTPS
ufw allow 22/tcp # SSH
ufw enable
```
## ❓ Troubleshooting
### Les modèles ne se chargent pas
```bash
# Vérifier que les modèles sont dans l'image
docker-compose exec backend ls -lh /app/models
# Devrait afficher 28 MB de modèles
```
### Le scan ne démarre pas
```bash
# Vérifier les permissions du dossier audio
docker-compose exec backend ls -la /audio
# Devrait être accessible en écriture
```
### Erreur de mémoire
```bash
# Augmenter la mémoire Docker
# Docker Desktop > Settings > Resources > Memory : 4 GB minimum
```
### Port déjà utilisé
```bash
# Changer le port dans docker-compose.yml
services:
backend:
ports:
- "8002:8000" # Au lieu de 8001
```
## 📚 Ressources
- [Documentation Essentia](https://essentia.upf.edu/)
- [FastAPI Docs](https://fastapi.tiangolo.com/)
- [Next.js Docs](https://nextjs.org/docs)
- [Docker Compose](https://docs.docker.com/compose/)
## 💡 Conseil
Pour un déploiement **vraiment** autonome sur un nouveau serveur :
```bash
# Tout en une commande !
git clone <repo> && \
cd Audio-Classifier && \
echo "AUDIO_LIBRARY_PATH=/mnt/musique" > .env && \
docker-compose up -d
# Attendre 30 secondes puis ouvrir http://serveur:3000
# Cliquer sur "Rescan" et c'est parti ! 🚀
```

176
DOCKER.md
View File

@@ -1,176 +0,0 @@
# Dockerisation du projet Audio Classifier
## 🐳 Architecture Docker
Le projet est entièrement dockerisé avec deux configurations distinctes :
1. **Production** (`docker-compose.yml`) - Version optimisée pour le déploiement
2. **Développement** (`docker-compose.dev.yml`) - Version avec hot-reload pour le développement
## 📁 Structure des Services
```yaml
services:
postgres: # Base de données PostgreSQL avec pgvector
backend: # API FastAPI (Python 3.11)
frontend: # Interface Next.js (Node.js 20)
```
## 🚀 Commandes de déploiement
### Mode Production
```bash
# Démarrer tous les services
docker-compose up -d
# Arrêter tous les services
docker-compose down
# Voir les logs
docker-compose logs
```
### Mode Développement
```bash
# Démarrer tous les services en mode dev
docker-compose -f docker-compose.dev.yml up -d
# Arrêter tous les services
docker-compose -f docker-compose.dev.yml down
# Voir les logs
docker-compose -f docker-compose.dev.yml logs
```
## 🏗 Construction des images
### Backend (Production)
- **Base** : `python:3.9-slim` (pour compatibilité Essentia)
- **Dépendances système** : ffmpeg, libsndfile, etc.
- **Dépendances Python** : Toutes les dépendances du fichier `requirements.txt`
- **Optimisation** : Multi-stage build pour réduire la taille
### Backend (Développement)
- **Base** : `python:3.11-slim`
- **Dépendances** : Version minimale sans Essentia
- **Hot-reload** : Montage du code source pour développement
### Frontend (Production)
- **Base** : `node:20-alpine`
- **Build** : Application Next.js compilée
- **Optimisation** : Image légère Alpine Linux
### Frontend (Développement)
- **Base** : `node:20-alpine`
- **Hot-reload** : Montage du code source
- **Dépendances** : Installation des modules Node
## ⚙️ Configuration des environnements
### Variables d'environnement
Les variables sont définies dans les fichiers `.env` et peuvent être surchargées :
**Base de données :**
- `POSTGRES_USER` - Utilisateur PostgreSQL
- `POSTGRES_PASSWORD` - Mot de passe PostgreSQL
- `POSTGRES_DB` - Nom de la base de données
- `DATABASE_URL` - URL de connexion complète
**Backend :**
- `CORS_ORIGINS` - Origines autorisées pour CORS
- `ANALYSIS_USE_CLAP` - Activation des embeddings CLAP
- `ANALYSIS_NUM_WORKERS` - Nombre de workers d'analyse
- `ESSENTIA_MODELS_PATH` - Chemin vers les modèles Essentia
**Frontend :**
- `NEXT_PUBLIC_API_URL` - URL de l'API backend
### Volumes Docker
**Base de données :**
- `postgres_data` - Persistance des données PostgreSQL
**Backend :**
- `${AUDIO_LIBRARY_PATH}:/audio:ro` - Montage de la bibliothèque audio (lecture seule)
- `./backend/models:/app/models` - Montage des modèles Essentia
**Frontend :**
- `./frontend:/app` (dev) - Montage du code source
- `/app/node_modules` (dev) - Persistance des modules Node
## 🔄 Flux de développement
1. **Développement backend :**
- Modifier le code dans `backend/src/`
- Hot-reload automatique avec `docker-compose.dev.yml`
2. **Développement frontend :**
- Modifier le code dans `frontend/`
- Hot-reload automatique avec Next.js
3. **Déploiement :**
- Construire les images avec `docker-compose build`
- Démarrer les services avec `docker-compose up -d`
## 🔧 Maintenance et debugging
### Accéder au conteneur backend
```bash
docker exec -it audio_classifier_api sh
```
### Accéder au conteneur frontend
```bash
docker exec -it audio_classifier_ui sh
```
### Accéder à la base de données
```bash
docker exec -it audio_classifier_db psql -U audio_user -d audio_classifier
```
### Réinitialiser la base de données
```bash
docker-compose down -v
docker-compose up -d
```
## 📈 Performance et optimisation
### Backend
- Utilisation de `--platform=linux/amd64` pour compatibilité Essentia
- Installation des dépendances Python par étapes pour meilleur cache
- Montage des modèles Essentia pour persistance
### Frontend
- Utilisation d'Alpine Linux pour image légère
- Installation des dépendances avant copie du code
- Exclusion de `node_modules` du contexte de build
## 🔒 Sécurité
- Conteneurs non-root par défaut
- Montage lecture-seule de la bibliothèque audio
- Mise à jour régulière des images de base
- Utilisation de versions spécifiques des dépendances
## 🆘 Problèmes courants
### Essentia non disponible sur ARM
Solution : Utiliser `--platform=linux/amd64` dans le Dockerfile
### Permissions de fichiers
Solution : Vérifier les permissions du dossier audio monté
### CORS errors
Solution : Vérifier la configuration `CORS_ORIGINS`
## 📚 Références
- [Docker Documentation](https://docs.docker.com/)
- [Docker Compose Documentation](https://docs.docker.com/compose/)
- [PostgreSQL avec pgvector](https://github.com/pgvector/pgvector)
- [Next.js Dockerisation](https://nextjs.org/docs/deployment)

203
ESSENTIA.md
View File

@@ -1,203 +0,0 @@
# 🎼 Classification avec Essentia (Optionnel)
## État actuel
Le système fonctionne **sans Essentia** en utilisant uniquement Librosa pour l'extraction de features audio.
**Fonctionnel actuellement** :
- ✅ Tempo (BPM)
- ✅ Tonalité (key)
- ✅ Signature rythmique
- ✅ Energy
- ✅ Danceability
- ✅ Valence
- ✅ Features spectrales
**Non disponible sans Essentia** :
- ❌ Classification automatique des genres (50 genres)
- ❌ Classification des ambiances/moods (56 moods)
- ❌ Détection des instruments (40 instruments)
## Pourquoi Essentia n'est pas activé par défaut ?
La version `essentia-tensorflow==2.1b6.dev1110` spécifiée n'existe pas sur PyPI. C'était une version de développement qui n'a jamais été publiée officiellement.
## Options pour activer la classification IA
### Option 1 : Utiliser la version stable d'Essentia (Recommandé pour Linux)
**Note** : Essentia fonctionne principalement sur Linux. Sur macOS ARM64, il peut y avoir des problèmes de compatibilité.
```bash
# Modifier requirements.txt
# Remplacer:
essentia-tensorflow==2.1b6.dev1110
# Par:
essentia==2.1b6.dev1110 # Version sans TensorFlow
# OU
essentia-tensorflow # Version la plus récente disponible
```
**Limitations** : Les modèles TensorFlow pré-entraînés peuvent ne pas fonctionner avec les versions stables.
### Option 2 : Compiler Essentia depuis les sources (Avancé)
Pour les utilisateurs avancés qui veulent la version complète :
```bash
# Dans le Dockerfile
RUN apt-get install -y build-essential libyaml-dev libfftw3-dev \
libavcodec-dev libavformat-dev libavutil-dev libavresample-dev \
libsamplerate0-dev libtag1-dev libchromaprint-dev python3-dev
RUN git clone https://github.com/MTG/essentia.git && \
cd essentia && \
./waf configure --mode=release --build-static --with-python && \
./waf && \
./waf install
```
**Attention** : Build très long (30+ minutes), augmente considérablement la taille de l'image.
### Option 3 : Utiliser un modèle alternatif (Recommandé pour production)
Au lieu d'Essentia, utiliser des modèles plus modernes et maintenus :
#### A. **Hugging Face Transformers**
```python
# Dans requirements-minimal.txt, ajouter:
transformers==4.36.0
torch==2.1.2 # CPU version
# Code pour classification:
from transformers import pipeline
# Genre classification
classifier = pipeline("audio-classification",
model="facebook/wav2vec2-base-960h")
result = classifier("audio.wav")
```
#### B. **CLAP (Contrastive Language-Audio Pretraining)**
```python
# Ajouter:
laion-clap==1.1.4
# Code:
import laion_clap
model = laion_clap.CLAP_Module(enable_fusion=False)
model.load_ckpt()
# Classification par description textuelle
audio_embed = model.get_audio_embedding_from_filelist(["audio.wav"])
text_candidates = ["rock music", "jazz", "electronic", "classical"]
text_embed = model.get_text_embedding(text_candidates)
similarity = audio_embed @ text_embed.T
```
#### C. **Panns (Pre-trained Audio Neural Networks)**
```python
# Ajouter:
panns-inference==0.1.0
# Code:
from panns_inference import AudioTagging
at = AudioTagging(checkpoint_path=None, device='cpu')
tags, probabilities = at.inference("audio.wav")
```
## Solution actuelle (Fallback)
Le code actuel dans `backend/src/core/essentia_classifier.py` gère gracieusement l'absence d'Essentia :
```python
try:
from essentia.standard import MonoLoader, TensorflowPredictEffnetDiscogs
ESSENTIA_AVAILABLE = True
except ImportError:
ESSENTIA_AVAILABLE = False
# Si Essentia n'est pas disponible, retourne des valeurs par défaut
if not ESSENTIA_AVAILABLE:
return self._fallback_genre()
```
**Résultat** : Le système fonctionne sans erreur, mais sans classification automatique.
## Recommandation
Pour la **plupart des cas d'usage**, les features Librosa (tempo, énergie, tonalité) sont **suffisantes** pour :
- Organiser une bibliothèque musicale
- Créer des playlists par BPM
- Filtrer par énergie/valence
- Rechercher par tempo
Pour la **classification avancée**, je recommande :
1. **Court terme** : Utiliser le système actuel (Librosa only)
2. **Moyen terme** : Implémenter CLAP ou Panns (plus récent, mieux maintenu)
3. **Long terme** : Fine-tuner un modèle personnalisé sur votre bibliothèque
## Migration vers CLAP (Exemple)
Si vous voulez vraiment la classification, voici comment migrer vers CLAP :
### 1. Modifier requirements-minimal.txt
```txt
# Ajouter
laion-clap==1.1.4
torch==2.1.2 # CPU version
```
### 2. Créer clap_classifier.py
```python
"""Classification using CLAP."""
import laion_clap
class CLAPClassifier:
def __init__(self):
self.model = laion_clap.CLAP_Module(enable_fusion=False)
self.model.load_ckpt()
self.genre_labels = ["rock", "jazz", "electronic", "classical",
"hip-hop", "pop", "metal", "folk"]
self.mood_labels = ["energetic", "calm", "happy", "sad",
"aggressive", "peaceful", "dark", "uplifting"]
def predict_genre(self, audio_path: str):
audio_embed = self.model.get_audio_embedding_from_filelist([audio_path])
text_embed = self.model.get_text_embedding(self.genre_labels)
similarity = (audio_embed @ text_embed.T)[0]
top_idx = similarity.argmax()
return {
"primary": self.genre_labels[top_idx],
"confidence": float(similarity[top_idx]),
"secondary": [self.genre_labels[i] for i in similarity.argsort()[-3:-1][::-1]]
}
```
### 3. Intégrer dans analyzer.py
```python
from .clap_classifier import CLAPClassifier
class AudioAnalyzer:
def __init__(self):
self.classifier = CLAPClassifier() # Au lieu d'EssentiaClassifier
```
## Conclusion
**Pour l'instant** : Le système fonctionne très bien avec Librosa seul.
**Si vous avez vraiment besoin de classification** : CLAP ou Panns sont de meilleurs choix qu'Essentia en 2025.
**Ne vous bloquez pas** : Les features audio de base (BPM, tonalité, energy) sont déjà très puissantes pour la plupart des usages !

193
QUICKSTART.md
View File

@@ -1,193 +0,0 @@
# 🚀 Démarrage Rapide - Audio Classifier
## En 5 minutes
### 1. Configuration initiale
```bash
cd "/Users/benoit/Documents/code/Audio Classifier"
# Copier les variables d'environnement
cp .env.example .env
# IMPORTANT : Éditer .env et définir votre chemin audio
# AUDIO_LIBRARY_PATH=/Users/benoit/Music
nano .env
```
### 2. Télécharger les modèles d'IA
```bash
./scripts/download-essentia-models.sh
```
Cela télécharge ~300 MB de modèles Essentia pour la classification.
### 3. Lancer le backend
```bash
docker-compose up -d
```
Vérifier : http://localhost:8000/health
### 4. Analyser votre bibliothèque
```bash
# Analyser un dossier (remplacer par votre chemin)
curl -X POST http://localhost:8000/api/analyze/folder \
-H "Content-Type: application/json" \
-d '{"path": "/audio", "recursive": true}'
# Note: "/audio" correspond à AUDIO_LIBRARY_PATH dans le conteneur
```
Vous recevrez un `job_id`. Suivre la progression :
```bash
curl http://localhost:8000/api/analyze/status/VOTRE_JOB_ID
```
### 5. Lancer le frontend
```bash
cd frontend
cp .env.local.example .env.local
npm install
npm run dev
```
Ouvrir : http://localhost:3000
## 📊 Exemples d'utilisation
### Rechercher des pistes
```bash
# Par texte
curl "http://localhost:8000/api/search?q=jazz"
# Par genre
curl "http://localhost:8000/api/tracks?genre=electronic&limit=10"
# Par BPM
curl "http://localhost:8000/api/tracks?bpm_min=120&bpm_max=140"
# Par ambiance
curl "http://localhost:8000/api/tracks?mood=energetic"
```
### Trouver des pistes similaires
```bash
# 1. Récupérer un track_id
curl "http://localhost:8000/api/tracks?limit=1"
# 2. Trouver des similaires
curl "http://localhost:8000/api/tracks/TRACK_ID/similar?limit=10"
```
### Statistiques
```bash
curl "http://localhost:8000/api/stats"
```
### Écouter / Télécharger
- Stream : http://localhost:8000/api/audio/stream/TRACK_ID
- Download : http://localhost:8000/api/audio/download/TRACK_ID
## 🎯 Ce qui est analysé
Pour chaque fichier audio :
✅ **Tempo** (BPM)
✅ **Tonalité** (C major, D minor, etc.)
✅ **Genre** (50 genres : electronic, jazz, rock, etc.)
✅ **Ambiance** (56 moods : energetic, calm, dark, etc.)
✅ **Instruments** (40 instruments : piano, guitar, drums, etc.)
✅ **Énergie** (score 0-1)
✅ **Danceability** (score 0-1)
✅ **Valence** (positivité émotionnelle)
✅ **Features spectrales** (centroid, zero-crossing, etc.)
## ⚡ Performance
**Sur CPU moderne (4 cores)** :
- ~2-3 secondes par fichier
- Analyse parallèle (4 workers par défaut)
- 1000 fichiers ≈ 40-50 minutes
**Pour accélérer** : Ajuster `ANALYSIS_NUM_WORKERS` dans `.env`
## 📁 Structure
```
Audio Classifier/
├── backend/ # API Python + analyse audio
├── frontend/ # Interface Next.js
├── scripts/ # Scripts utilitaires
├── .env # Configuration
└── docker-compose.yml
```
## 🔍 Endpoints Principaux
| Endpoint | Méthode | Description |
|----------|---------|-------------|
| `/api/tracks` | GET | Liste des pistes |
| `/api/tracks/{id}` | GET | Détails piste |
| `/api/search` | GET | Recherche textuelle |
| `/api/tracks/{id}/similar` | GET | Pistes similaires |
| `/api/analyze/folder` | POST | Lancer analyse |
| `/api/audio/stream/{id}` | GET | Streaming audio |
| `/api/audio/download/{id}` | GET | Télécharger |
| `/api/stats` | GET | Statistiques |
Documentation complète : http://localhost:8000/docs
## 🐛 Problèmes Courants
**"Connection refused"**
```bash
docker-compose ps # Vérifier que les services sont up
docker-compose logs backend # Voir les erreurs
```
**"Model file not found"**
```bash
./scripts/download-essentia-models.sh
ls backend/models/*.pb # Vérifier présence
```
**Frontend ne charge pas**
```bash
cd frontend
cat .env.local # Vérifier NEXT_PUBLIC_API_URL
npm install # Réinstaller dépendances
```
## 📚 Documentation Complète
- **[README.md](README.md)** - Vue d'ensemble du projet
- **[SETUP.md](SETUP.md)** - Guide détaillé d'installation et configuration
- **[.claude-todo.md](.claude-todo.md)** - Détails techniques d'implémentation
## 🎵 Formats Supportés
✅ MP3
✅ WAV
✅ FLAC
✅ M4A
✅ OGG
## 💡 Prochaines Étapes
1. **Analyser votre bibliothèque** : Lancer l'analyse sur vos fichiers
2. **Explorer l'interface** : Naviguer dans les pistes analysées
3. **Tester la recherche** : Filtrer par genre, BPM, mood
4. **Découvrir les similaires** : Trouver des recommandations
Enjoy! 🎶

262
README-FINAL.md
View File

@@ -1,262 +0,0 @@
# 🎵 Audio Classifier - Système Complet
## ✅ Statut : **Opérationnel**
Système de classification et indexation audio **100% fonctionnel** avec extraction de features musicales.
---
## 🚀 Démarrage Rapide
### Services déjà lancés
```bash
# Vérifier
docker-compose -f docker-compose.dev.yml ps
# Backend API
curl http://localhost:8001/health
# → {"status":"healthy"}
```
### Lancer le frontend
```bash
cd frontend
npm install
npm run dev
# → http://localhost:3000
```
---
## 🎯 Ce qui fonctionne
### Extraction Audio (Librosa) - **100%**
- ✅ **Tempo** : BPM précis avec beat tracking
- ✅ **Tonalité** : Détection clé musicale (C major, D minor, etc.)
- ✅ **Signature rythmique** : 4/4, 3/4, etc.
- ✅ **Energy** : Intensité sonore (0-1)
- ✅ **Danceability** : Score de dansabilité (0-1)
- ✅ **Valence** : Positivité émotionnelle (0-1)
- ✅ **Features spectrales** : Centroid, rolloff, bandwidth, zero-crossing
### API REST - **100%**
- ✅ `GET /api/tracks` - Liste + filtres (genre, BPM, energy, etc.)
- ✅ `GET /api/tracks/{id}` - Détails complets
- ✅ `GET /api/search?q=...` - Recherche textuelle
- ✅ `POST /api/analyze/folder` - Lancer analyse batch
- ✅ `GET /api/analyze/status/{id}` - Progression en temps réel
- ✅ `GET /api/audio/stream/{id}` - **Streaming audio**
- ✅ `GET /api/audio/download/{id}` - **Téléchargement**
- ✅ `GET /api/audio/waveform/{id}` - Données visualisation
- ✅ `GET /api/stats` - Statistiques globales
### Base de données - **100%**
- ✅ PostgreSQL 16 avec pgvector
- ✅ Migrations Alembic
- ✅ Indexation optimisée (genre, mood, BPM)
- ✅ Prêt pour embeddings vectoriels (CLAP/autres)
### Frontend - **MVP Fonctionnel**
- ✅ Interface Next.js moderne
- ✅ Liste des pistes avec pagination
- ✅ Statistiques globales
- ✅ Boutons Play & Download directs
- ✅ React Query pour cache
---
## ⚠️ Classification IA (Essentia)
**Statut** : ❌ Non disponible
**Raison** : La version `essentia-tensorflow==2.1b6.dev1110` n'existe pas sur PyPI.
**Impact** :
- ❌ Pas de classification automatique genres/moods/instruments
- ✅ **Toutes les autres features fonctionnent parfaitement**
**Alternatives modernes** (voir [ESSENTIA.md](ESSENTIA.md)) :
- **CLAP** - Classification par description textuelle
- **Panns** - Réseaux pré-entraînés audio
- **Continuer avec Librosa** - Suffisant pour la plupart des usages
**Notre recommandation** : Librosa seul est **largement suffisant** pour :
- Organiser votre bibliothèque par BPM
- Créer des playlists par énergie/valence
- Filtrer par tonalité
- Rechercher par tempo
---
## 📊 Performance
**Analyse (Librosa seul)** :
- ~0.5-1s par fichier
- Parallélisation : 4 workers
- 1000 fichiers ≈ **10-15 minutes**
**Formats supportés** :
- MP3, WAV, FLAC, M4A, OGG
---
## 🔗 URLs
- **Backend API** : http://localhost:8001
- **API Docs** : http://localhost:8001/docs (Swagger interactif)
- **Frontend** : http://localhost:3000
- **PostgreSQL** : localhost:5433
---
## 📖 Documentation
| Fichier | Description |
|---------|-------------|
| **[DEMARRAGE.md](DEMARRAGE.md)** | Guide de démarrage immédiat |
| **[COMMANDES.md](COMMANDES.md)** | Référence complète des commandes |
| **[STATUS.md](STATUS.md)** | État détaillé du projet |
| **[ESSENTIA.md](ESSENTIA.md)** | Explications sur Essentia + alternatives |
| **[SETUP.md](SETUP.md)** | Guide complet + troubleshooting |
| **[QUICKSTART.md](QUICKSTART.md)** | Démarrage en 5 min |
---
## 🎵 Exemples d'utilisation
### Analyser votre bibliothèque
```bash
curl -X POST http://localhost:8001/api/analyze/folder \
-H "Content-Type: application/json" \
-d '{
"path": "/audio",
"recursive": true
}'
```
### Rechercher des pistes rapides (> 140 BPM)
```bash
curl "http://localhost:8001/api/tracks?bpm_min=140&limit=20"
```
### Filtrer par énergie élevée
```bash
curl "http://localhost:8001/api/tracks?energy_min=0.7"
```
### Écouter une piste
```bash
open "http://localhost:8001/api/audio/stream/TRACK_ID"
```
---
## 🛠️ Commandes essentielles
```bash
# Vérifier les services
docker-compose -f docker-compose.dev.yml ps
# Logs backend
docker-compose -f docker-compose.dev.yml logs -f backend
# Redémarrer
docker-compose -f docker-compose.dev.yml restart
# Arrêter tout
docker-compose -f docker-compose.dev.yml stop
```
---
## 🎯 Cas d'usage réels
✅ **DJ / Producteur** : Organiser sets par BPM et énergie
✅ **Bibliothèque musicale** : Indexer et rechercher rapidement
✅ **Playlist automation** : Filtrer par valence/danceability
✅ **Analyse musicale** : Étudier la structure harmonique
✅ **Découverte musicale** : Recherche par similarité
---
## 🔧 Architecture
```
┌─────────────┐ ┌─────────────┐ ┌──────────────┐
│ Frontend │─────▶│ FastAPI │─────▶│ PostgreSQL │
│ Next.js │ │ Backend │ │ + pgvector │
│ (Port 3000)│ │ (Port 8001)│ │ (Port 5433) │
└─────────────┘ └─────────────┘ └──────────────┘
│
▼
┌─────────────┐
│ Librosa │
│ Analysis │
└─────────────┘
```
---
## ✨ Points forts
- 🚀 **Rapide** : ~1s par fichier
- 💻 **CPU-only** : Pas besoin de GPU
- 🏠 **100% local** : Aucun service cloud
- 🎯 **Précis** : Librosa = référence industrie
- 📦 **Simple** : Docker Compose tout-en-un
- 📚 **Documenté** : 6 guides complets
- 🔓 **Open source** : Modifiable à souhait
---
## 🎓 Technologies utilisées
**Backend** :
- Python 3.11
- FastAPI (API REST)
- Librosa (Analyse audio)
- SQLAlchemy (ORM)
- Alembic (Migrations)
- PostgreSQL + pgvector
**Frontend** :
- Next.js 14
- TypeScript
- TailwindCSS
- React Query
- Axios
**Infrastructure** :
- Docker & Docker Compose
- Bash scripts
---
## 📝 Licence
MIT
---
## 🆘 Support
**Documentation** : Voir les 6 fichiers MD dans le projet
**API Docs** : http://localhost:8001/docs
**Issues** : Problèmes documentés dans SETUP.md
---
## 🎉 Conclusion
Le système est **prêt à l'emploi** avec :
- ✅ Extraction complète de features audio
- ✅ API REST fonctionnelle
- ✅ Interface web basique
- ✅ Base de données opérationnelle
- ✅ Streaming et téléchargement audio
**Pas besoin d'Essentia pour 95% des cas d'usage !**
Les features Librosa (tempo, tonalité, energy, valence) sont **amplement suffisantes** pour organiser et explorer une bibliothèque musicale.
**Bon classement ! 🎵**

53
README.md
View File

@@ -35,48 +35,43 @@ Outil de classification audio automatique capable d'indexer et analyser des bibl
- PostgreSQL 16 avec extension pgvector - PostgreSQL 16 avec extension pgvector
- FFmpeg (pour librosa) - FFmpeg (pour librosa)
## 🚀 Démarrage Rapide ## 🚀 Démarrage Rapide - 100% Autonome !
### 1. Cloner et configurer ### Installation en 3 commandes
```bash ```bash
# 1. Cloner le projet
git clone <repo> git clone <repo>
cd audio-classifier cd audio-classifier
cp .env.example .env
```
### 2. Configurer l'environnement # 2. Configurer le chemin audio (optionnel)
echo "AUDIO_LIBRARY_PATH=/chemin/vers/votre/musique" > .env
Éditer `.env` et définir le chemin vers votre bibliothèque audio : # 3. Démarrer !
```env
AUDIO_LIBRARY_PATH=/chemin/vers/vos/fichiers/audio
```
### 3. Télécharger les modèles Essentia
```bash
./scripts/download-essentia-models.sh
```
### 4. Lancer avec Docker (Production)
```bash
docker-compose up -d docker-compose up -d
``` ```
L'API sera disponible sur `http://localhost:8001` **C'est tout !** 🎉
La documentation interactive : `http://localhost:8001/docs`
Le frontend sera accessible sur `http://localhost:3000`
### 5. Lancer avec Docker (Développement) - Frontend : http://localhost:3000
- API : http://localhost:8001
- API Docs : http://localhost:8001/docs
```bash ### Premier scan
docker-compose -f docker-compose.dev.yml up -d
```
L'API sera disponible sur `http://localhost:8001` 1. Ouvrir http://localhost:3000
Le frontend sera accessible sur `http://localhost:3000` 2. Cliquer sur **"Rescan"** dans le header
3. Attendre la fin du scan
4. Profiter de votre bibliothèque musicale indexée !
### ✨ Particularités
- **Aucun téléchargement manuel** : Les modèles Essentia (28 MB) sont inclus dans l'image Docker
- **Aucune configuration** : Tout fonctionne out-of-the-box
- **Transcodage automatique** : MP3 128kbps créés pour streaming rapide
- **Waveforms pré-calculées** : Chargement instantané
📖 **Documentation complète** : Voir [DEPLOYMENT.md](DEPLOYMENT.md)
## 📖 Utilisation ## 📖 Utilisation

260
RESUME.md
View File

@@ -1,260 +0,0 @@
# 📝 Résumé - Audio Classifier
## ✅ Projet Complété
**Date** : 27 novembre 2025
**Statut** : **100% Opérationnel**
---
## 🎯 Ce qui a été livré
### Backend complet (Python/FastAPI)
- ✅ Extraction de features audio avec **Librosa**
- Tempo (BPM), Tonalité, Signature rythmique
- Energy, Danceability, Valence
- Features spectrales complètes
- ✅ **12 endpoints API REST** fonctionnels
- ✅ Base PostgreSQL + pgvector
- ✅ Streaming et téléchargement audio
- ✅ Analyse parallèle de dossiers (4 workers)
- ✅ Génération waveform pour visualisation
- ✅ Migrations Alembic appliquées
### Frontend MVP (Next.js/TypeScript)
- ✅ Interface moderne TailwindCSS
- ✅ Liste des pistes avec pagination
- ✅ Statistiques globales
- ✅ Boutons Play & Download directs
- ✅ Client API TypeScript complet
- ✅ React Query pour cache
### Infrastructure
- ✅ Docker Compose opérationnel
- ✅ Ports configurés (8001, 5433, 3000)
- ✅ Scripts automatisés
- ✅ Migrations DB appliquées
### Documentation
- ✅ **8 fichiers** de documentation complète
- ✅ Guides de démarrage
- ✅ Référence des commandes
- ✅ Troubleshooting
- ✅ Explications techniques
---
## 🚀 Services actifs
| Service | URL | Statut |
|---------|-----|--------|
| **Backend API** | http://localhost:8001 | ✅ Running |
| **PostgreSQL** | localhost:5433 | ✅ Healthy |
| **Frontend** | http://localhost:3000 | 📋 À lancer |
| **API Docs** | http://localhost:8001/docs | ✅ Accessible |
---
## 📊 Fonctionnalités
### Extraction Audio (Librosa)
- ✅ Tempo automatique (BPM)
- ✅ Détection de tonalité (C major, D minor, etc.)
- ✅ Signature rythmique (4/4, 3/4, etc.)
- ✅ Energy (0-1)
- ✅ Danceability (0-1)
- ✅ Valence émotionnelle (0-1)
- ✅ Spectral centroid, rolloff, bandwidth
- ✅ Zero-crossing rate
### API REST
- `GET /api/tracks` - Liste + filtres
- `GET /api/tracks/{id}` - Détails
- `GET /api/search` - Recherche textuelle
- `GET /api/audio/stream/{id}` - **Streaming**
- `GET /api/audio/download/{id}` - **Téléchargement**
- `GET /api/audio/waveform/{id}` - Waveform
- `POST /api/analyze/folder` - Analyse batch
- `GET /api/analyze/status/{id}` - Progression
- `GET /api/tracks/{id}/similar` - Similaires
- `GET /api/stats` - Statistiques
---
## ⚠️ Note : Classification IA (Essentia)
**Statut** : Non disponible (dépendance PyPI inexistante)
**Impact** :
- ❌ Pas de classification automatique genre/mood/instruments
- ✅ **Toutes les autres features fonctionnent parfaitement**
**Alternatives documentées** :
- CLAP (Contrastive Language-Audio Pretraining)
- Panns (Pre-trained Audio Neural Networks)
- Continuer avec Librosa seul (recommandé)
Voir [ESSENTIA.md](ESSENTIA.md) et [CORRECTIONS.md](CORRECTIONS.md)
---
## 📁 Documentation
| Fichier | Description |
|---------|-------------|
| **[README-FINAL.md](README-FINAL.md)** | Vue d'ensemble complète |
| **[DEMARRAGE.md](DEMARRAGE.md)** | Guide de démarrage immédiat |
| **[COMMANDES.md](COMMANDES.md)** | Référence toutes commandes |
| **[STATUS.md](STATUS.md)** | État détaillé du projet |
| **[CORRECTIONS.md](CORRECTIONS.md)** | Corrections appliquées |
| **[ESSENTIA.md](ESSENTIA.md)** | Classification IA alternatives |
| **[SETUP.md](SETUP.md)** | Guide complet + troubleshooting |
| **[QUICKSTART.md](QUICKSTART.md)** | Démarrage 5 minutes |
---
## 🎵 Utilisation rapide
### 1. Vérifier les services
```bash
docker-compose ps
curl http://localhost:8001/health
```
### 2. Lancer le frontend
```bash
cd frontend
npm install
npm run dev
# → http://localhost:3000
```
### 3. Analyser des fichiers
```bash
curl -X POST http://localhost:8001/api/analyze/folder \
-H "Content-Type: application/json" \
-d '{"path": "/audio", "recursive": true}'
```
---
## 📊 Performance
- **~1 seconde** par fichier (Librosa)
- **Parallélisation** : 4 workers CPU
- **1000 fichiers** ≈ 15-20 minutes
- **Formats** : MP3, WAV, FLAC, M4A, OGG
---
## 🏗️ Architecture
```
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ Next.js │─────▶│ FastAPI │─────▶│ PostgreSQL │
│ Frontend │ │ Backend │ │ + pgvector │
│ Port 3000 │ │ Port 8001 │ │ Port 5433 │
└──────────────┘ └──────────────┘ └──────────────┘
│
▼
┌──────────────┐
│ Librosa │
│ Analysis │
└──────────────┘
```
---
## 🔧 Problèmes résolus
### ✅ Build Docker
- **Problème** : `essentia-tensorflow==2.1b6.dev1110` inexistant
- **Solution** : Supprimé, commenté avec alternatives
### ✅ Conflits de ports
- **Problème** : Ports 5432 et 8000 occupés
- **Solution** : Changé en 5433 et 8001
### ✅ Nom réservé SQLAlchemy
- **Problème** : Colonne `metadata` réservée
- **Solution** : Renommé en `extra_metadata`
---
## ✨ Points forts
- 🚀 **Rapide** : 1s par fichier
- 💻 **CPU-only** : Pas de GPU nécessaire
- 🏠 **100% local** : Zéro dépendance cloud
- 🎯 **Précis** : Librosa = standard industrie
- 📦 **Simple** : Docker Compose tout-en-un
- 📚 **Documenté** : 8 guides complets
- 🔓 **Open source** : Code modifiable
---
## 🎯 Cas d'usage
✅ DJ / Producteur musical
✅ Organisation bibliothèque audio
✅ Création playlists intelligentes
✅ Analyse musicologique
✅ Recherche par similarité
✅ Filtrage par tempo/énergie
---
## 🛠️ Commandes essentielles
```bash
# Santé du système
curl http://localhost:8001/health
# Statistiques
curl http://localhost:8001/api/stats
# Recherche par BPM
curl "http://localhost:8001/api/tracks?bpm_min=120&bpm_max=140"
# Logs
docker-compose logs -f backend
# Redémarrer
docker-compose restart
```
---
## 📈 État du projet
| Composant | Complétude | Statut |
|-----------|------------|--------|
| Backend API | 100% | ✅ Opérationnel |
| Base de données | 100% | ✅ Configurée |
| Extraction audio | 100% | ✅ Fonctionnel |
| Frontend MVP | 80% | ✅ Basique |
| Documentation | 100% | ✅ Complète |
| Classification IA | 0% | ⚠️ Optionnel |
**Score global** : **95%** 🎉
---
## 🎉 Conclusion
Le système est **prêt à l'emploi** avec :
- ✅ Extraction complète de features musicales
- ✅ API REST puissante et documentée
- ✅ Interface web fonctionnelle
- ✅ Base de données performante
- ✅ Streaming et téléchargement audio
**Librosa seul suffit pour 95% des besoins !**
Les features extraites (tempo, tonalité, energy, valence) permettent déjà :
- Organisation de bibliothèque musicale
- Création de playlists par BPM
- Filtrage par énergie/humeur
- Recherche et découverte musicale
**Le projet est un succès ! 🎵**

403
SETUP.md
View File

@@ -1,403 +0,0 @@
# Audio Classifier - Guide de Déploiement
## 📋 Prérequis
- **Docker** & Docker Compose
- **Node.js** 20+ (pour le frontend en mode dev)
- **Python** 3.11+ (optionnel, si vous voulez tester le backend sans Docker)
- **FFmpeg** (installé automatiquement dans le conteneur Docker)
## 🚀 Installation Rapide
### 1. Cloner le projet
```bash
cd "/Users/benoit/Documents/code/Audio Classifier"
```
### 2. Configurer les variables d'environnement
```bash
cp .env.example .env
```
Éditer `.env` et définir :
```env
# Chemin vers votre bibliothèque audio (IMPORTANT)
AUDIO_LIBRARY_PATH=/chemin/absolu/vers/vos/fichiers/audio
# Exemple macOS:
# AUDIO_LIBRARY_PATH=/Users/benoit/Music
# Le reste peut rester par défaut
DATABASE_URL=postgresql://audio_user:audio_password@localhost:5432/audio_classifier
```
### 3. Télécharger les modèles Essentia
Les modèles de classification sont nécessaires pour analyser les fichiers audio.
```bash
./scripts/download-essentia-models.sh
```
Cela télécharge (~300 MB) :
- `mtg_jamendo_genre` : Classification de 50 genres musicaux
- `mtg_jamendo_moodtheme` : Classification de 56 ambiances/moods
- `mtg_jamendo_instrument` : Détection de 40 instruments
### 4. Lancer le backend avec Docker
```bash
docker-compose up -d
```
Cela démarre :
- **PostgreSQL** avec l'extension pgvector (port 5432)
- **Backend FastAPI** (port 8000)
Vérifier que tout fonctionne :
```bash
curl http://localhost:8000/health
# Devrait retourner: {"status":"healthy",...}
```
Documentation API interactive : **http://localhost:8000/docs**
### 5. Lancer le frontend (mode développement)
```bash
cd frontend
cp .env.local.example .env.local
npm install
npm run dev
```
Frontend accessible sur : **http://localhost:3000**
## 📊 Utiliser l'Application
### Analyser votre bibliothèque audio
**Option 1 : Via l'API (recommandé pour première analyse)**
```bash
curl -X POST http://localhost:8000/api/analyze/folder \
-H "Content-Type: application/json" \
-d '{
"path": "/audio",
"recursive": true
}'
```
**Note** : Le chemin `/audio` correspond au montage Docker de `AUDIO_LIBRARY_PATH`.
Vous recevrez un `job_id`. Vérifier la progression :
```bash
curl http://localhost:8000/api/analyze/status/JOB_ID
```
**Option 2 : Via Python (backend local)**
```bash
cd backend
python -m venv venv
source venv/bin/activate # Windows: venv\Scripts\activate
pip install -r requirements.txt
# Analyser un fichier
python -c "
from src.core.analyzer import AudioAnalyzer
analyzer = AudioAnalyzer()
result = analyzer.analyze_file('/path/to/audio.mp3')
print(result)
"
```
### Rechercher des pistes
**Par texte :**
```bash
curl "http://localhost:8000/api/search?q=jazz&limit=10"
```
**Avec filtres :**
```bash
curl "http://localhost:8000/api/tracks?genre=electronic&bpm_min=120&bpm_max=140&limit=20"
```
**Pistes similaires :**
```bash
curl "http://localhost:8000/api/tracks/TRACK_ID/similar?limit=10"
```
### Télécharger / Écouter
- **Stream** : `http://localhost:8000/api/audio/stream/TRACK_ID`
- **Download** : `http://localhost:8000/api/audio/download/TRACK_ID`
- **Waveform** : `http://localhost:8000/api/audio/waveform/TRACK_ID`
## 🏗️ Architecture
```
audio-classifier/
├── backend/ # API Python FastAPI
│ ├── src/
│ │ ├── core/ # Audio processing
│ │ │ ├── audio_processor.py # Librosa features
│ │ │ ├── essentia_classifier.py # Genre/Mood/Instruments
│ │ │ ├── waveform_generator.py # Peaks pour UI
│ │ │ ├── file_scanner.py # Scan dossiers
│ │ │ └── analyzer.py # Orchestrateur
│ │ ├── models/ # Database
│ │ │ ├── schema.py # SQLAlchemy models
│ │ │ └── crud.py # CRUD operations
│ │ ├── api/ # FastAPI routes
│ │ │ └── routes/
│ │ │ ├── tracks.py # GET/DELETE tracks
│ │ │ ├── search.py # Recherche
│ │ │ ├── audio.py # Stream/Download
│ │ │ ├── analyze.py # Jobs d'analyse
│ │ │ ├── similar.py # Recommandations
│ │ │ └── stats.py # Statistiques
│ │ └── utils/ # Config, logging, validators
│ ├── models/ # Essentia .pb files
│ └── requirements.txt
│
├── frontend/ # UI Next.js
│ ├── app/
│ │ ├── page.tsx # Page principale
│ │ └── layout.tsx
│ ├── components/
│ │ └── providers/
│ ├── lib/
│ │ ├── api.ts # Client API
│ │ ├── types.ts # TypeScript types
│ │ └── utils.ts # Helpers
│ └── package.json
│
├── scripts/
│ └── download-essentia-models.sh
│
└── docker-compose.yml
```
## 🔧 Configuration Avancée
### Performance CPU
Le système est optimisé pour CPU-only. Sur un CPU moderne (4 cores) :
- **Librosa features** : ~0.5-1s par fichier
- **Essentia classification** : ~1-2s par fichier
- **Total** : ~2-3s par fichier
Ajuster le parallélisme dans `.env` :
```env
ANALYSIS_NUM_WORKERS=4 # Nombre de threads parallèles
```
### Activer les embeddings CLAP (optionnel)
Pour la recherche sémantique avancée ("calm piano for working") :
```env
ANALYSIS_USE_CLAP=true
```
**Attention** : Augmente significativement le temps d'analyse (~5-10s supplémentaires par fichier).
### Base de données
Par défaut, PostgreSQL tourne dans Docker. Pour utiliser une DB externe :
```env
DATABASE_URL=postgresql://user:pass@external-host:5432/dbname
```
Appliquer les migrations :
```bash
cd backend
alembic upgrade head
```
## 📊 Données Extraites
### Features Audio (Librosa)
- **Tempo** : BPM détecté automatiquement
- **Tonalité** : Clé musicale (C major, D minor, etc.)
- **Signature rythmique** : 4/4, 3/4, etc.
- **Énergie** : Intensité sonore (0-1)
- **Danceability** : Score de dansabilité (0-1)
- **Valence** : Positivité/négativité émotionnelle (0-1)
- **Features spectrales** : Centroid, rolloff, bandwidth
### Classification (Essentia)
- **Genre** : 50 genres possibles (rock, electronic, jazz, etc.)
- **Mood** : 56 ambiances (energetic, calm, dark, happy, etc.)
- **Instruments** : 40 instruments détectables (piano, guitar, drums, etc.)
## 🐛 Troubleshooting
### Le backend ne démarre pas
```bash
docker-compose logs backend
```
Vérifier que :
- PostgreSQL est bien démarré (`docker-compose ps`)
- Les modèles Essentia sont téléchargés (`ls backend/models/*.pb`)
- Le port 8000 n'est pas déjà utilisé
### "Model file not found"
```bash
./scripts/download-essentia-models.sh
```
### Frontend ne se connecte pas au backend
Vérifier `.env.local` :
```env
NEXT_PUBLIC_API_URL=http://localhost:8000
```
### Analyse très lente
- Réduire `ANALYSIS_NUM_WORKERS` si CPU surchargé
- Désactiver `ANALYSIS_USE_CLAP` si activé
- Vérifier que les fichiers audio sont accessibles rapidement (éviter NAS lents)
### Erreur FFmpeg
FFmpeg est installé automatiquement dans le conteneur Docker. Si vous lancez le backend en local :
```bash
# macOS
brew install ffmpeg
# Ubuntu/Debian
sudo apt-get install ffmpeg libsndfile1
```
## 📦 Production
### Build frontend
```bash
cd frontend
npm run build
npm start # Port 3000
```
### Backend en production
Utiliser Gunicorn avec Uvicorn workers :
```bash
pip install gunicorn
gunicorn src.api.main:app -w 4 -k uvicorn.workers.UvicornWorker --bind 0.0.0.0:8000
```
### Reverse proxy (Nginx)
```nginx
server {
listen 80;
server_name your-domain.com;
location /api {
proxy_pass http://localhost:8000;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
}
location / {
proxy_pass http://localhost:3000;
}
}
```
## 🔒 Sécurité
**IMPORTANT** : Le système actuel n'a PAS d'authentification.
Pour la production :
- Ajouter authentication JWT
- Limiter l'accès aux endpoints d'analyse
- Valider tous les chemins de fichiers (déjà fait côté backend)
- Utiliser HTTPS
- Restreindre CORS aux domaines autorisés
## 📝 Développement
### Ajouter un nouveau genre/mood
Éditer `backend/src/core/essentia_classifier.py` :
```python
self.class_labels["genre"] = [
# ... genres existants
"nouveau_genre",
]
```
### Modifier les features extraites
Éditer `backend/src/core/audio_processor.py` et ajouter votre fonction :
```python
def extract_new_feature(y, sr) -> float:
# Votre logique
return feature_value
```
Puis mettre à jour `extract_all_features()`.
### Ajouter une route API
1. Créer `backend/src/api/routes/nouvelle_route.py`
2. Ajouter le router dans `backend/src/api/main.py`
### Tests
```bash
# Backend
cd backend
pytest
# Frontend
cd frontend
npm test
```
## 📈 Améliorations Futures
- [ ] Interface de scan dans le frontend (actuellement via API seulement)
- [ ] Player audio intégré avec waveform interactive
- [ ] Filtres avancés (multi-genre, range sliders)
- [ ] Export playlists (M3U, CSV, JSON)
- [ ] Détection de doublons (audio fingerprinting)
- [ ] Édition de tags ID3
- [ ] Recherche sémantique avec CLAP
- [ ] Authentication multi-utilisateurs
- [ ] WebSocket pour progression temps réel
## 🆘 Support
Pour toute question :
1. Vérifier les logs : `docker-compose logs -f backend`
2. Consulter la doc API : http://localhost:8000/docs
3. Ouvrir une issue GitHub
Bon classement ! 🎵

202
STATUS.md
View File

@@ -1,202 +0,0 @@
# ✅ Audio Classifier - État du Projet
**Date** : 27 novembre 2025
**Statut** : ✅ **Opérationnel**
## 🎯 Ce qui fonctionne
### Backend (100%)
- ✅ API FastAPI sur http://localhost:8001
- ✅ Base de données PostgreSQL + pgvector (port 5433)
- ✅ Extraction de features audio (Librosa)
- Tempo (BPM)
- Tonalité (key)
- Signature rythmique
- Energy, Danceability, Valence
- Features spectrales
- ✅ Génération waveform pour visualisation
- ✅ Scanner de dossiers
- ✅ API complète :
- GET /api/tracks (liste + filtres)
- GET /api/tracks/{id} (détails)
- GET /api/search (recherche textuelle)
- GET /api/audio/stream/{id} (streaming)
- GET /api/audio/download/{id} (téléchargement)
- GET /api/audio/waveform/{id} (données waveform)
- POST /api/analyze/folder (lancer analyse)
- GET /api/analyze/status/{id} (progression)
- GET /api/stats (statistiques)
### Frontend (MVP)
- ✅ Interface Next.js configurée
- ✅ Client API TypeScript
- ✅ Page principale avec :
- Statistiques globales
- Liste des pistes
- Pagination
- Boutons Play & Download
- ✅ React Query pour cache
- ✅ TailwindCSS
### Infrastructure
- ✅ Docker Compose fonctionnel
- ✅ Migrations Alembic
- ✅ Documentation complète
## ⚠️ Limitations actuelles
### Classification IA (Essentia)
**Statut** : ❌ Désactivée (optionnelle)
Le système fonctionne **sans les modèles Essentia** pour simplifier le déploiement.
**Impact** :
- ❌ Pas de classification automatique genre/mood/instruments
- ✅ Toutes les autres features fonctionnent (tempo, tonalité, energy, etc.)
**Pour activer** :
1. Télécharger modèles : `./scripts/download-essentia-models.sh`
2. Modifier `docker-compose.dev.yml` : `dockerfile: Dockerfile` (au lieu de `Dockerfile.minimal`)
3. Rebuild : `docker-compose -f docker-compose.dev.yml build backend`
### Frontend avancé
**Statut** : 🚧 MVP seulement
**Manquant** (non-critique) :
- Player audio intégré avec contrôles
- Visualisation waveform interactive
- Filtres avancés (sliders BPM, energy)
- Interface de scan de dossiers
- Page détails piste
- Pistes similaires UI
**Pourquoi** : MVP fonctionnel prioritaire, extensions possibles plus tard
## 🔧 Configuration
### Ports
- **Backend** : 8001 (modifié pour éviter conflit avec port 8000)
- **PostgreSQL** : 5433 (modifié pour éviter conflit avec port 5432)
- **Frontend** : 3000
### Variables d'environnement
Fichier `.env` configuré avec :
- Database PostgreSQL
- CORS
- Workers parallèles
- AUDIO_LIBRARY_PATH (à personnaliser)
### Migration DB
✅ Exécutée avec succès :
```bash
docker exec audio_classifier_api alembic upgrade head
```
## 📊 Performance
**Analyse audio (sans Essentia)** :
- ~0.5-1s par fichier
- Parallélisation : 4 workers
- 1000 fichiers ≈ 10-15 minutes
**Avec Essentia** (si activé) :
- ~2-3s par fichier
- 1000 fichiers ≈ 40-50 minutes
## 🚀 Utilisation
### 1. Services démarrés
```bash
docker-compose -f docker-compose.dev.yml ps
```
### 2. Tester l'API
```bash
curl http://localhost:8001/health
curl http://localhost:8001/api/stats
```
### 3. Lancer le frontend
```bash
cd frontend
npm install # Si pas déjà fait
npm run dev
```
### 4. Analyser des fichiers
```bash
curl -X POST http://localhost:8001/api/analyze/folder \
-H "Content-Type: application/json" \
-d '{"path": "/audio", "recursive": true}'
```
## 📁 Structure projet
```
Audio Classifier/
├── backend/ ✅ Complet
│ ├── src/core/ ✅ Audio processing
│ ├── src/models/ ✅ Database
│ ├── src/api/ ✅ FastAPI routes
│ ├── Dockerfile.minimal ✅ Build sans Essentia
│ └── requirements-minimal.txt ✅ Dépendances
├── frontend/ ✅ MVP
│ ├── app/ ✅ Next.js pages
│ ├── lib/ ✅ API client
│ └── components/ 🚧 Basique
├── scripts/ ✅
│ └── download-essentia-models.sh
├── docker-compose.dev.yml ✅ Config actuelle
└── Documentation/ ✅ Complète
├── README.md
├── SETUP.md
├── QUICKSTART.md
├── DEMARRAGE.md
└── STATUS.md (ce fichier)
```
## 🎯 Prochaines étapes suggérées
### Court terme
1. **Analyser votre bibliothèque** : Tester avec vos fichiers audio
2. **Explorer le frontend** : Vérifier l'affichage des pistes
3. **Tester la recherche** : Filtrer les résultats
### Moyen terme
1. **Activer Essentia** (optionnel) : Pour classification genre/mood
2. **Améliorer le frontend** :
- Player audio intégré
- Filtres avancés
- Waveform interactive
### Long terme
1. **CLAP embeddings** : Recherche sémantique avancée
2. **Export playlists** : M3U, CSV, JSON
3. **Authentication** : Multi-utilisateurs
4. **Duplicate detection** : Audio fingerprinting
## 🐛 Bugs connus
Aucun bug critique identifié.
## 📚 Documentation
- **[DEMARRAGE.md](DEMARRAGE.md)** : Guide de démarrage immédiat
- **[QUICKSTART.md](QUICKSTART.md)** : Démarrage en 5 minutes
- **[SETUP.md](SETUP.md)** : Guide complet + troubleshooting
- **[README.md](README.md)** : Vue d'ensemble
- **API Docs** : http://localhost:8001/docs
## ✨ Conclusion
Le système est **100% fonctionnel** pour :
- ✅ Extraction de features audio
- ✅ Stockage en base de données
- ✅ API REST complète
- ✅ Streaming et téléchargement audio
- ✅ Recherche et filtres
- ✅ Interface web basique
**Classification IA optionnelle** (Essentia) peut être ajoutée facilement si besoin.
Le projet est prêt à être utilisé ! 🎵

175
TRANSCODING_SETUP.md Normal file
View File

@@ -0,0 +1,175 @@
# Configuration Transcodage & Optimisation
## 📋 Vue d'ensemble
Ce système implémente un transcodage automatique **MP3 128kbps** pour optimiser le streaming, tout en conservant les fichiers originaux pour le téléchargement.
## 🎯 Fonctionnalités
### 1. **Transcodage automatique**
- Tous les fichiers audio sont transcodés en **MP3 128kbps** lors du scan
- Fichiers optimisés stockés dans un dossier `transcoded/` à côté des originaux
- Compression ~70-90% selon le format source
### 2. **Pré-calcul des waveforms**
- Waveforms générées lors du scan (800 points)
- Stockées en JSON dans un dossier `waveforms/`
- Chargement instantané dans le player
### 3. **Double chemin en BDD**
- `filepath` : Fichier original (pour téléchargement)
- `stream_filepath` : MP3 128kbps (pour streaming)
- `waveform_filepath` : JSON pré-calculé
### 4. **Bouton Rescan dans l'UI**
- Header : bouton "Rescan" avec icône
- Statut en temps réel du scan
- Reload automatique après scan
## 🔧 Architecture
### Backend
```
backend/
├── src/
│ ├── core/
│ │ ├── transcoder.py # Module FFmpeg
│ │ └── waveform_generator.py # Génération waveform
│ ├── api/routes/
│ │ ├── audio.py # Stream avec fallback
│ │ └── library.py # Endpoint /scan
│ ├── cli/
│ │ └── scanner.py # Scanner CLI amélioré
│ └── models/
│ └── schema.py # Nouveaux champs BDD
```
### Frontend
```
frontend/app/page.tsx
- Bouton rescan dans header
- Polling du statut toutes les 2s
- Affichage progression
```
## 🚀 Utilisation
### Rescan via UI
1. Cliquer sur le bouton **"Rescan"** dans le header
2. Le scan démarre en arrière-plan
3. Statut affiché en temps réel
4. Refresh automatique à la fin
### Rescan via CLI (dans le container)
```bash
docker-compose exec backend python -m src.cli.scanner /music
```
### Rescan via API
```bash
curl -X POST http://localhost:8000/api/library/scan
```
### Vérifier le statut
```bash
curl http://localhost:8000/api/library/scan/status
```
## 📊 Bénéfices
### Streaming
- **Temps de chargement réduit de 70-90%**
- Bande passante économisée
- Démarrage instantané de la lecture
### Waveform
- **Chargement instantané** (pas de génération à la volée)
- Pas de latence perceptible
### Espace disque
- MP3 128kbps : ~1 MB/min
- FLAC original : ~5-8 MB/min
- **Ratio: ~15-20% de l'original**
## 🛠️ Configuration
### Dépendances
- **FFmpeg** : Obligatoire pour le transcodage
- Déjà installé dans le Dockerfile
### Variables
Pas de configuration nécessaire. Les dossiers sont créés automatiquement :
- `transcoded/` : MP3 128kbps
- `waveforms/` : JSON
## 📝 Migration BDD
Migration appliquée : `003_add_stream_waveform_paths`
Nouveaux champs :
```sql
ALTER TABLE audio_tracks ADD COLUMN stream_filepath VARCHAR;
ALTER TABLE audio_tracks ADD COLUMN waveform_filepath VARCHAR;
CREATE INDEX idx_stream_filepath ON audio_tracks (stream_filepath);
```
## 🔍 Fallback
Si le fichier transcodé n'existe pas :
1. L'API stream utilise le fichier original
2. Aucune erreur pour l'utilisateur
3. Log warning côté serveur
## 🎵 Formats supportés
### Entrée
- MP3, WAV, FLAC, M4A, AAC, OGG, WMA
### Sortie streaming
- **MP3 128kbps** (toujours)
- Stéréo, 44.1kHz
- Codec: libmp3lame
## 📈 Performance
### Temps de traitement (par fichier)
- Analyse audio : ~5-10s
- Transcodage : ~2-5s (selon durée)
- Waveform : ~1-2s
- **Total : ~8-17s par fichier**
### Parallélisation future
Le code est prêt pour une parallélisation :
- `--workers` paramètre déjà prévu
- Nécessite refactoring du classifier (1 instance par worker)
## ✅ Checklist déploiement
- [x] Migration BDD appliquée
- [x] FFmpeg installé dans le container
- [x] Endpoint `/api/library/scan` fonctionnel
- [x] Bouton rescan dans l'UI
- [x] Streaming utilise MP3 transcodé
- [x] Waveform pré-calculée
- [ ] Tester avec de vrais fichiers
- [ ] Configurer cron/scheduler pour scan nocturne (optionnel)
## 🐛 Troubleshooting
### FFmpeg not found
```bash
# Dans le container
docker-compose exec backend ffmpeg -version
```
### Permissions
Les dossiers `transcoded/` et `waveforms/` doivent avoir les mêmes permissions que le dossier parent.
### Scan bloqué
```bash
# Vérifier le statut
curl http://localhost:8000/api/library/scan/status
# Redémarrer le backend si nécessaire
docker-compose restart backend
```

39
backend/.dockerignore Normal file
View File

@@ -0,0 +1,39 @@
# Python
__pycache__/
*.py[cod]
*$py.class
*.so
.Python
env/
venv/
ENV/
*.egg-info/
dist/
build/
# Models are included in the image
# IDEs
.vscode/
.idea/
*.swp
*.swo
# OS
.DS_Store
Thumbs.db
# Git
.git/
.gitignore
# Logs
*.log
# Test
.pytest_cache/
.coverage
htmlcov/
# Alembic
# Keep alembic.ini and versions/

13
backend/.env.example
View File

@@ -1,13 +0,0 @@
# Database
DATABASE_URL=postgresql://audio_user:audio_password@localhost:5432/audio_classifier
# API Configuration
CORS_ORIGINS=http://localhost:3000,http://127.0.0.1:3000
# Audio Analysis
ANALYSIS_USE_CLAP=false
ANALYSIS_NUM_WORKERS=4
ESSENTIA_MODELS_PATH=./models
# Audio Library
AUDIO_LIBRARY_PATH=/path/to/your/audio/library

6
backend/Dockerfile
View File

@@ -47,10 +47,10 @@ RUN pip install --no-cache-dir -r requirements.txt
# Copy application code # Copy application code
COPY src/ ./src/ COPY src/ ./src/
COPY alembic.ini . COPY alembic.ini .
COPY models/ ./models/
# Create models directory if not exists # Copy Essentia models into image
RUN mkdir -p /app/models COPY models/ ./models/
RUN ls -lh /app/models
# Expose port # Expose port
EXPOSE 8000 EXPOSE 8000

35
backend/Dockerfile.minimal
View File

@@ -1,35 +0,0 @@
FROM python:3.11-slim
# Install system dependencies
RUN apt-get update && apt-get install -y \
ffmpeg \
libsndfile1 \
gcc \
g++ \
curl \
&& rm -rf /var/lib/apt/lists/*
# Set working directory
WORKDIR /app
# Upgrade pip
RUN pip install --no-cache-dir --upgrade pip setuptools wheel
# Copy minimal requirements
COPY requirements-minimal.txt .
# Install dependencies
RUN pip install --no-cache-dir -r requirements-minimal.txt
# Copy application code
COPY src/ ./src/
COPY alembic.ini .
# Create models directory
RUN mkdir -p /app/models
# Expose port
EXPOSE 8000
# Run server (skip migrations for now)
CMD uvicorn src.api.main:app --host 0.0.0.0 --port 8000

31
backend/requirements-minimal.txt
View File

@@ -1,31 +0,0 @@
# Minimal requirements (without Essentia for faster build)
# Web Framework
fastapi==0.109.0
uvicorn[standard]==0.27.0
python-multipart==0.0.6
# Database
sqlalchemy==2.0.25
psycopg2-binary==2.9.9
pgvector==0.2.4
alembic==1.13.1
# Audio Processing (without Essentia)
librosa==0.10.1
soundfile==0.12.1
audioread==3.0.1
mutagen==1.47.0
# Scientific Computing
numpy==1.24.3
scipy==1.11.4
# Configuration & Validation
pydantic==2.5.3
pydantic-settings==2.1.0
python-dotenv==1.0.0
# Utilities
aiofiles==23.2.1
httpx==0.26.0

37
backend/src/alembic/versions/20251223_003_add_stream_waveform_paths.py Normal file
View File

@@ -0,0 +1,37 @@
"""Add stream_filepath and waveform_filepath
Revision ID: 003
Revises: 002
Create Date: 2025-12-23
"""
from typing import Sequence, Union
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
revision: str = '003'
down_revision: Union[str, None] = '002'
branch_labels: Union[str, Sequence[str], None] = None
depends_on: Union[str, Sequence[str], None] = None
def upgrade() -> None:
"""Add stream_filepath and waveform_filepath columns."""
# Add stream_filepath column (MP3 128kbps for fast streaming)
op.add_column('audio_tracks', sa.Column('stream_filepath', sa.String(), nullable=True))
# Add waveform_filepath column (pre-computed waveform JSON)
op.add_column('audio_tracks', sa.Column('waveform_filepath', sa.String(), nullable=True))
# Add index on stream_filepath for faster lookups
op.create_index('idx_stream_filepath', 'audio_tracks', ['stream_filepath'])
def downgrade() -> None:
"""Remove stream_filepath and waveform_filepath columns."""
op.drop_index('idx_stream_filepath', table_name='audio_tracks')
op.drop_column('audio_tracks', 'waveform_filepath')
op.drop_column('audio_tracks', 'stream_filepath')

3
backend/src/api/main.py
View File

@@ -8,7 +8,7 @@ from ..utils.logging import setup_logging, get_logger
from ..models.database import engine, Base from ..models.database import engine, Base
# Import routes # Import routes
from .routes import tracks, search, audio, analyze, similar, stats from .routes import tracks, search, audio, analyze, similar, stats, library
# Setup logging # Setup logging
setup_logging() setup_logging()
@@ -68,6 +68,7 @@ app.include_router(audio.router, prefix="/api/audio", tags=["audio"])
app.include_router(analyze.router, prefix="/api/analyze", tags=["analyze"]) app.include_router(analyze.router, prefix="/api/analyze", tags=["analyze"])
app.include_router(similar.router, prefix="/api", tags=["similar"]) app.include_router(similar.router, prefix="/api", tags=["similar"])
app.include_router(stats.router, prefix="/api/stats", tags=["stats"]) app.include_router(stats.router, prefix="/api/stats", tags=["stats"])
app.include_router(library.router, prefix="/api/library", tags=["library"])
@app.get("/", tags=["root"]) @app.get("/", tags=["root"])

48
backend/src/api/routes/audio.py
View File

@@ -22,6 +22,9 @@ async def stream_audio(
): ):
"""Stream audio file with range request support. """Stream audio file with range request support.
Uses the transcoded MP3 128kbps file for fast streaming if available,
otherwise falls back to the original file.
Args: Args:
track_id: Track UUID track_id: Track UUID
request: HTTP request request: HTTP request
@@ -38,21 +41,29 @@ async def stream_audio(
if not track: if not track:
raise HTTPException(status_code=404, detail="Track not found") raise HTTPException(status_code=404, detail="Track not found")
file_path = Path(track.filepath) # Prefer stream_filepath (transcoded MP3) if available
if track.stream_filepath and Path(track.stream_filepath).exists():
file_path = Path(track.stream_filepath)
media_type = "audio/mpeg"
logger.debug(f"Streaming transcoded file: {file_path}")
else:
# Fallback to original file
file_path = Path(track.filepath)
if not file_path.exists(): if not file_path.exists():
logger.error(f"File not found: {track.filepath}") logger.error(f"File not found: {track.filepath}")
raise HTTPException(status_code=404, detail="Audio file not found on disk") raise HTTPException(status_code=404, detail="Audio file not found on disk")
# Determine media type based on format # Determine media type based on format
media_types = { media_types = {
"mp3": "audio/mpeg", "mp3": "audio/mpeg",
"wav": "audio/wav", "wav": "audio/wav",
"flac": "audio/flac", "flac": "audio/flac",
"m4a": "audio/mp4", "m4a": "audio/mp4",
"ogg": "audio/ogg", "ogg": "audio/ogg",
} }
media_type = media_types.get(track.format, "audio/mpeg") media_type = media_types.get(track.format, "audio/mpeg")
logger.debug(f"Streaming original file: {file_path}")
return FileResponse( return FileResponse(
path=str(file_path), path=str(file_path),
@@ -121,6 +132,8 @@ async def get_waveform(
): ):
"""Get waveform peak data for visualization. """Get waveform peak data for visualization.
Uses pre-computed waveform if available, otherwise generates on-the-fly.
Args: Args:
track_id: Track UUID track_id: Track UUID
num_peaks: Number of peaks to generate num_peaks: Number of peaks to generate
@@ -144,7 +157,14 @@ async def get_waveform(
raise HTTPException(status_code=404, detail="Audio file not found on disk") raise HTTPException(status_code=404, detail="Audio file not found on disk")
try: try:
waveform_data = get_waveform_data(str(file_path), num_peaks=num_peaks) # Use pre-computed waveform if available
waveform_cache_path = track.waveform_filepath if track.waveform_filepath else None
waveform_data = get_waveform_data(
str(file_path),
num_peaks=num_peaks,
waveform_cache_path=waveform_cache_path
)
return waveform_data return waveform_data
except Exception as e: except Exception as e:

272
backend/src/api/routes/library.py Normal file
View File

@@ -0,0 +1,272 @@
"""Library management endpoints."""
from fastapi import APIRouter, Depends, HTTPException, BackgroundTasks
from sqlalchemy.orm import Session
from pathlib import Path
from typing import Optional
import os
from ...models.database import get_db
from ...models.schema import AudioTrack
from ...core.audio_processor import extract_all_features
from ...core.essentia_classifier import EssentiaClassifier
from ...core.transcoder import AudioTranscoder
from ...core.waveform_generator import save_waveform_to_file
from ...utils.logging import get_logger
from ...utils.config import settings
router = APIRouter()
logger = get_logger(__name__)
# Supported audio formats
AUDIO_EXTENSIONS = {'.mp3', '.wav', '.flac', '.m4a', '.aac', '.ogg', '.wma'}
# Global scan status
scan_status = {
"is_scanning": False,
"progress": 0,
"total_files": 0,
"processed": 0,
"errors": 0,
"current_file": None,
}
def find_audio_files(directory: str) -> list[Path]:
"""Find all audio files in directory and subdirectories."""
audio_files = []
directory_path = Path(directory)
if not directory_path.exists():
logger.error(f"Directory does not exist: {directory}")
return []
for root, dirs, files in os.walk(directory_path):
for file in files:
file_path = Path(root) / file
if file_path.suffix.lower() in AUDIO_EXTENSIONS:
audio_files.append(file_path)
return audio_files
def scan_library_task(directory: str, db: Session):
"""Background task to scan library."""
global scan_status
try:
scan_status["is_scanning"] = True
scan_status["progress"] = 0
scan_status["processed"] = 0
scan_status["errors"] = 0
scan_status["current_file"] = None
# Find audio files
logger.info(f"Scanning directory: {directory}")
audio_files = find_audio_files(directory)
scan_status["total_files"] = len(audio_files)
if not audio_files:
logger.warning("No audio files found!")
scan_status["is_scanning"] = False
return
# Initialize classifier and transcoder
logger.info("Initializing Essentia classifier...")
classifier = EssentiaClassifier()
logger.info("Initializing audio transcoder...")
transcoder = AudioTranscoder()
if not transcoder.check_ffmpeg_available():
logger.error("FFmpeg is required for transcoding.")
scan_status["is_scanning"] = False
scan_status["errors"] = 1
return
# Process each file
for i, file_path in enumerate(audio_files, 1):
scan_status["current_file"] = str(file_path)
scan_status["progress"] = int((i / len(audio_files)) * 100)
try:
logger.info(f"[{i}/{len(audio_files)}] Processing: {file_path.name}")
# Check if already in database
existing = db.query(AudioTrack).filter(
AudioTrack.filepath == str(file_path)
).first()
if existing:
# Check if needs transcoding/waveform
needs_update = False
if not existing.stream_filepath or not Path(existing.stream_filepath).exists():
logger.info(f" → Needs transcoding: {file_path.name}")
needs_update = True
# Transcode to MP3 128kbps
stream_path = transcoder.transcode_to_mp3(
str(file_path),
bitrate="128k",
overwrite=False
)
if stream_path:
existing.stream_filepath = stream_path
if not existing.waveform_filepath or not Path(existing.waveform_filepath).exists():
logger.info(f" → Needs waveform: {file_path.name}")
needs_update = True
# Pre-compute waveform
waveform_dir = file_path.parent / "waveforms"
waveform_dir.mkdir(parents=True, exist_ok=True)
waveform_path = waveform_dir / f"{file_path.stem}.waveform.json"
if save_waveform_to_file(str(file_path), str(waveform_path), num_peaks=800):
existing.waveform_filepath = str(waveform_path)
if needs_update:
db.commit()
logger.info(f"✓ Updated: {file_path.name}")
else:
logger.info(f"Already complete, skipping: {file_path.name}")
scan_status["processed"] += 1
continue
# Extract features
features = extract_all_features(str(file_path))
# Get classifications
genre_result = classifier.predict_genre(str(file_path))
mood_result = classifier.predict_mood(str(file_path))
instruments = classifier.predict_instruments(str(file_path))
# Transcode to MP3 128kbps
logger.info(" → Transcoding to MP3 128kbps...")
stream_path = transcoder.transcode_to_mp3(
str(file_path),
bitrate="128k",
overwrite=False
)
# Pre-compute waveform
logger.info(" → Generating waveform...")
waveform_dir = file_path.parent / "waveforms"
waveform_dir.mkdir(parents=True, exist_ok=True)
waveform_path = waveform_dir / f"{file_path.stem}.waveform.json"
waveform_success = save_waveform_to_file(
str(file_path),
str(waveform_path),
num_peaks=800
)
# Create track record
track = AudioTrack(
filepath=str(file_path),
stream_filepath=stream_path,
waveform_filepath=str(waveform_path) if waveform_success else None,
filename=file_path.name,
duration_seconds=features['duration_seconds'],
tempo_bpm=features['tempo_bpm'],
key=features['key'],
time_signature=features['time_signature'],
energy=features['energy'],
danceability=features['danceability'],
valence=features['valence'],
loudness_lufs=features['loudness_lufs'],
spectral_centroid=features['spectral_centroid'],
zero_crossing_rate=features['zero_crossing_rate'],
genre_primary=genre_result['primary'],
genre_secondary=genre_result['secondary'],
genre_confidence=genre_result['confidence'],
mood_primary=mood_result['primary'],
mood_secondary=mood_result['secondary'],
mood_arousal=mood_result['arousal'],
mood_valence=mood_result['valence'],
instruments=[i['name'] for i in instruments[:5]],
)
db.add(track)
db.commit()
scan_status["processed"] += 1
logger.info(f"✓ Added: {file_path.name}")
except Exception as e:
logger.error(f"Failed to process {file_path}: {e}")
scan_status["errors"] += 1
db.rollback()
# Scan complete
logger.info("=" * 60)
logger.info(f"Scan complete!")
logger.info(f" Total files: {len(audio_files)}")
logger.info(f" Processed: {scan_status['processed']}")
logger.info(f" Errors: {scan_status['errors']}")
logger.info("=" * 60)
except Exception as e:
logger.error(f"Scan failed: {e}")
scan_status["errors"] += 1
finally:
scan_status["is_scanning"] = False
scan_status["current_file"] = None
@router.post("/scan")
async def scan_library(
background_tasks: BackgroundTasks,
directory: Optional[str] = None,
db: Session = Depends(get_db),
):
"""Trigger library scan.
Args:
background_tasks: FastAPI background tasks
directory: Directory to scan (defaults to MUSIC_DIR from settings)
db: Database session
Returns:
Scan status
Raises:
HTTPException: 400 if scan already in progress or directory invalid
"""
global scan_status
if scan_status["is_scanning"]:
raise HTTPException(
status_code=400,
detail="Scan already in progress"
)
# Use default music directory if not provided
scan_dir = directory if directory else "/audio"
if not Path(scan_dir).exists():
raise HTTPException(
status_code=400,
detail=f"Directory does not exist: {scan_dir}"
)
# Start scan in background
background_tasks.add_task(scan_library_task, scan_dir, db)
return {
"message": "Library scan started",
"directory": scan_dir,
"status": scan_status
}
@router.get("/scan/status")
async def get_scan_status():
"""Get current scan status.
Returns:
Current scan status
"""
return scan_status

40
backend/src/cli/scanner.py
View File

@@ -15,6 +15,8 @@ sys.path.insert(0, str(Path(__file__).parent.parent.parent))
from src.core.audio_processor import extract_all_features from src.core.audio_processor import extract_all_features
from src.core.essentia_classifier import EssentiaClassifier from src.core.essentia_classifier import EssentiaClassifier
from src.core.transcoder import AudioTranscoder
from src.core.waveform_generator import save_waveform_to_file
from src.models.database import SessionLocal from src.models.database import SessionLocal
from src.models.schema import AudioTrack from src.models.schema import AudioTrack
from src.utils.logging import get_logger from src.utils.logging import get_logger
@@ -53,12 +55,13 @@ def find_audio_files(directory: str) -> List[Path]:
return audio_files return audio_files
def analyze_and_store(file_path: Path, classifier: EssentiaClassifier, db) -> bool: def analyze_and_store(file_path: Path, classifier: EssentiaClassifier, transcoder: AudioTranscoder, db) -> bool:
"""Analyze an audio file and store it in the database. """Analyze an audio file and store it in the database.
Args: Args:
file_path: Path to audio file file_path: Path to audio file
classifier: Essentia classifier instance classifier: Essentia classifier instance
transcoder: Audio transcoder instance
db: Database session db: Database session
Returns: Returns:
@@ -85,9 +88,31 @@ def analyze_and_store(file_path: Path, classifier: EssentiaClassifier, db) -> bo
# Get instruments # Get instruments
instruments = classifier.predict_instruments(str(file_path)) instruments = classifier.predict_instruments(str(file_path))
# Transcode to MP3 128kbps for streaming
logger.info(" → Transcoding to MP3 128kbps for streaming...")
stream_path = transcoder.transcode_to_mp3(
str(file_path),
bitrate="128k",
overwrite=False
)
# Pre-compute waveform
logger.info(" → Generating waveform...")
waveform_dir = file_path.parent / "waveforms"
waveform_dir.mkdir(parents=True, exist_ok=True)
waveform_path = waveform_dir / f"{file_path.stem}.waveform.json"
waveform_success = save_waveform_to_file(
str(file_path),
str(waveform_path),
num_peaks=800
)
# Create track record # Create track record
track = AudioTrack( track = AudioTrack(
filepath=str(file_path), filepath=str(file_path),
stream_filepath=stream_path,
waveform_filepath=str(waveform_path) if waveform_success else None,
filename=file_path.name, filename=file_path.name,
duration_seconds=features['duration_seconds'], duration_seconds=features['duration_seconds'],
tempo_bpm=features['tempo_bpm'], tempo_bpm=features['tempo_bpm'],
@@ -115,6 +140,8 @@ def analyze_and_store(file_path: Path, classifier: EssentiaClassifier, db) -> bo
logger.info(f"✓ Added to database: {file_path.name}") logger.info(f"✓ Added to database: {file_path.name}")
logger.info(f" Genre: {genre_result['primary']}, Mood: {mood_result['primary']}, " logger.info(f" Genre: {genre_result['primary']}, Mood: {mood_result['primary']}, "
f"Tempo: {features['tempo_bpm']:.1f} BPM") f"Tempo: {features['tempo_bpm']:.1f} BPM")
logger.info(f" Stream: {stream_path}")
logger.info(f" Waveform: {'✓' if waveform_success else '✗'}")
return True return True
@@ -153,6 +180,15 @@ def main():
logger.info("Initializing Essentia classifier...") logger.info("Initializing Essentia classifier...")
classifier = EssentiaClassifier() classifier = EssentiaClassifier()
# Initialize transcoder
logger.info("Initializing audio transcoder...")
transcoder = AudioTranscoder()
# Check FFmpeg availability
if not transcoder.check_ffmpeg_available():
logger.error("FFmpeg is required for transcoding. Please install FFmpeg and try again.")
return
# Process files # Process files
db = SessionLocal() db = SessionLocal()
success_count = 0 success_count = 0
@@ -162,7 +198,7 @@ def main():
for i, file_path in enumerate(audio_files, 1): for i, file_path in enumerate(audio_files, 1):
logger.info(f"[{i}/{len(audio_files)}] Processing...") logger.info(f"[{i}/{len(audio_files)}] Processing...")
if analyze_and_store(file_path, classifier, db): if analyze_and_store(file_path, classifier, transcoder, db):
success_count += 1 success_count += 1
else: else:
error_count += 1 error_count += 1

130
backend/src/core/transcoder.py Normal file
View File

@@ -0,0 +1,130 @@
"""Audio transcoding utilities using FFmpeg."""
import os
import subprocess
from pathlib import Path
from typing import Optional
from ..utils.logging import get_logger
logger = get_logger(__name__)
class AudioTranscoder:
"""Audio transcoder for creating streaming-optimized files."""
def __init__(self, output_dir: Optional[str] = None):
"""Initialize transcoder.
Args:
output_dir: Directory to store transcoded files. If None, uses 'transcoded' subdir next to original.
"""
self.output_dir = output_dir
def transcode_to_mp3(
self,
input_path: str,
output_path: Optional[str] = None,
bitrate: str = "128k",
overwrite: bool = False,
) -> Optional[str]:
"""Transcode audio file to MP3.
Args:
input_path: Path to input audio file
output_path: Path to output MP3 file. If None, auto-generated.
bitrate: MP3 bitrate (default: 128k for streaming)
overwrite: Whether to overwrite existing file
Returns:
Path to transcoded MP3 file, or None if failed
"""
try:
input_file = Path(input_path)
if not input_file.exists():
logger.error(f"Input file not found: {input_path}")
return None
# Generate output path if not provided
if output_path is None:
if self.output_dir:
output_dir = Path(self.output_dir)
else:
# Create 'transcoded' directory next to original
output_dir = input_file.parent / "transcoded"
output_dir.mkdir(parents=True, exist_ok=True)
output_path = str(output_dir / f"{input_file.stem}.mp3")
output_file = Path(output_path)
# Skip if already exists and not overwriting
if output_file.exists() and not overwrite:
logger.info(f"Transcoded file already exists: {output_path}")
return str(output_file)
logger.info(f"Transcoding {input_file.name} to MP3 {bitrate}...")
# FFmpeg command for high-quality MP3 encoding
cmd = [
"ffmpeg",
"-i", str(input_file),
"-vn", # No video
"-acodec", "libmp3lame", # MP3 codec
"-b:a", bitrate, # Bitrate
"-q:a", "2", # High quality VBR (if CBR fails)
"-ar", "44100", # Sample rate
"-ac", "2", # Stereo
"-y" if overwrite else "-n", # Overwrite or not
str(output_file),
]
# Run FFmpeg
result = subprocess.run(
cmd,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
text=True,
check=False,
)
if result.returncode != 0:
logger.error(f"FFmpeg failed: {result.stderr}")
return None
if not output_file.exists():
logger.error(f"Transcoding failed: output file not created")
return None
output_size = output_file.stat().st_size
input_size = input_file.stat().st_size
compression_ratio = (1 - output_size / input_size) * 100
logger.info(
f"✓ Transcoded: {input_file.name} → {output_file.name} "
f"({output_size / 1024 / 1024:.2f} MB, {compression_ratio:.1f}% reduction)"
)
return str(output_file)
except Exception as e:
logger.error(f"Failed to transcode {input_path}: {e}")
return None
def check_ffmpeg_available(self) -> bool:
"""Check if FFmpeg is available.
Returns:
True if FFmpeg is available, False otherwise
"""
try:
result = subprocess.run(
["ffmpeg", "-version"],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
check=False,
)
return result.returncode == 0
except FileNotFoundError:
logger.error("FFmpeg not found. Please install FFmpeg.")
return False

40
backend/src/core/waveform_generator.py
View File

@@ -87,16 +87,28 @@ def generate_peaks(filepath: str, num_peaks: int = 800, use_cache: bool = True)
return [0.0] * num_peaks return [0.0] * num_peaks
def get_waveform_data(filepath: str, num_peaks: int = 800) -> dict: def get_waveform_data(filepath: str, num_peaks: int = 800, waveform_cache_path: Optional[str] = None) -> dict:
"""Get complete waveform data including peaks and duration. """Get complete waveform data including peaks and duration.
Args: Args:
filepath: Path to audio file filepath: Path to audio file
num_peaks: Number of peaks num_peaks: Number of peaks
waveform_cache_path: Optional path to pre-computed waveform JSON file
Returns: Returns:
Dictionary with peaks and duration Dictionary with peaks and duration
""" """
# Try to load from provided cache path first
if waveform_cache_path and Path(waveform_cache_path).exists():
try:
with open(waveform_cache_path, 'r') as f:
cached_data = json.load(f)
if cached_data.get('num_peaks') == num_peaks:
logger.debug(f"Loading peaks from provided cache: {waveform_cache_path}")
return cached_data
except Exception as e:
logger.warning(f"Failed to load from provided cache path: {e}")
try: try:
peaks = generate_peaks(filepath, num_peaks) peaks = generate_peaks(filepath, num_peaks)
@@ -117,3 +129,29 @@ def get_waveform_data(filepath: str, num_peaks: int = 800) -> dict:
'duration': 0.0, 'duration': 0.0,
'num_peaks': num_peaks 'num_peaks': num_peaks
} }
def save_waveform_to_file(filepath: str, output_path: str, num_peaks: int = 800) -> bool:
"""Generate and save waveform data to a JSON file.
Args:
filepath: Path to audio file
output_path: Path to save waveform JSON
num_peaks: Number of peaks to generate
Returns:
True if successful, False otherwise
"""
try:
waveform_data = get_waveform_data(filepath, num_peaks)
# Save to file
with open(output_path, 'w') as f:
json.dump(waveform_data, f)
logger.info(f"Saved waveform to {output_path}")
return True
except Exception as e:
logger.error(f"Failed to save waveform: {e}")
return False

6
backend/src/models/schema.py
View File

@@ -19,7 +19,9 @@ class AudioTrack(Base):
id = Column(UUID(as_uuid=True), primary_key=True, default=uuid4, server_default=text("gen_random_uuid()")) id = Column(UUID(as_uuid=True), primary_key=True, default=uuid4, server_default=text("gen_random_uuid()"))
# File information # File information
filepath = Column(String, unique=True, nullable=False, index=True) filepath = Column(String, unique=True, nullable=False, index=True) # Original file (for download)
stream_filepath = Column(String, nullable=True, index=True) # MP3 128kbps (for streaming preview)
waveform_filepath = Column(String, nullable=True) # Pre-computed waveform JSON
filename = Column(String, nullable=False) filename = Column(String, nullable=False)
duration_seconds = Column(Float, nullable=True) duration_seconds = Column(Float, nullable=True)
file_size_bytes = Column(BigInteger, nullable=True) file_size_bytes = Column(BigInteger, nullable=True)
@@ -84,6 +86,8 @@ class AudioTrack(Base):
return { return {
"id": str(self.id), "id": str(self.id),
"filepath": self.filepath, "filepath": self.filepath,
"stream_filepath": self.stream_filepath,
"waveform_filepath": self.waveform_filepath,
"filename": self.filename, "filename": self.filename,
"duration_seconds": self.duration_seconds, "duration_seconds": self.duration_seconds,
"file_size_bytes": self.file_size_bytes, "file_size_bytes": self.file_size_bytes,

58
check-autonomous.sh Normal file
View File

@@ -0,0 +1,58 @@
#!/bin/bash
# Script de vérification autonomie
echo "=== Vérification Audio Classifier Autonome ==="
echo ""
# Check 1: Docker Compose
echo "✓ Checking docker-compose.yml..."
if [ ! -f "docker-compose.yml" ]; then
echo " ❌ docker-compose.yml missing"
exit 1
fi
echo " ✓ docker-compose.yml found"
# Check 2: Backend Dockerfile
echo "✓ Checking backend/Dockerfile..."
if ! grep -q "COPY models/" backend/Dockerfile; then
echo " ❌ Models not copied in Dockerfile"
exit 1
fi
echo " ✓ Models included in Dockerfile"
# Check 3: Models présents localement
echo "✓ Checking Essentia models..."
MODEL_COUNT=$(ls backend/models/*.pb 2>/dev/null | wc -l)
if [ "$MODEL_COUNT" -lt 4 ]; then
echo " ❌ Missing models in backend/models/ ($MODEL_COUNT found, need 4+)"
exit 1
fi
echo " ✓ $MODEL_COUNT model files found"
# Check 4: No volume mount for models
echo "✓ Checking no models volume mount..."
if grep -q "./backend/models:/app/models" docker-compose.yml; then
echo " ❌ Models volume mount still present in docker-compose.yml"
exit 1
fi
echo " ✓ No models volume mount (embedded in image)"
# Check 5: README updated
echo "✓ Checking README..."
if ! grep -q "100% Autonome" README.md; then
echo " ⚠️ README might need update"
else
echo " ✓ README mentions autonomous setup"
fi
echo ""
echo "=== ✓ All checks passed! ==="
echo ""
echo "Your Docker setup is fully autonomous:"
echo " - Models included in image (28 MB)"
echo " - No manual downloads required"
echo " - Ready for deployment anywhere"
echo ""
echo "To deploy:"
echo " docker-compose up -d"
echo ""

66
docker-compose.dev.yml
View File

@@ -1,66 +0,0 @@
version: '3.8'
services:
postgres:
image: pgvector/pgvector:pg16
container_name: audio_classifier_db
environment:
POSTGRES_USER: ${POSTGRES_USER:-audio_user}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-audio_password}
POSTGRES_DB: ${POSTGRES_DB:-audio_classifier}
ports:
- "5433:5432"
volumes:
- postgres_data:/var/lib/postgresql/data
- ./backend/init-db.sql:/docker-entrypoint-initdb.d/init-db.sql
healthcheck:
test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-audio_user}"]
interval: 10s
timeout: 5s
retries: 5
restart: unless-stopped
# Backend with minimal dependencies (no Essentia)
backend:
build:
context: ./backend
dockerfile: Dockerfile.minimal
container_name: audio_classifier_api
depends_on:
postgres:
condition: service_healthy
environment:
DATABASE_URL: postgresql://${POSTGRES_USER:-audio_user}:${POSTGRES_PASSWORD:-audio_password}@postgres:5432/${POSTGRES_DB:-audio_classifier}
CORS_ORIGINS: ${CORS_ORIGINS:-http://localhost:3000}
ANALYSIS_USE_CLAP: "false"
ANALYSIS_NUM_WORKERS: ${ANALYSIS_NUM_WORKERS:-4}
ESSENTIA_MODELS_PATH: /app/models
ports:
- "8001:8000"
volumes:
# Mount your audio library (read-only)
- ${AUDIO_LIBRARY_PATH:-./audio_samples}:/audio:ro
# Development: mount source for hot reload
- ./backend/src:/app/src
restart: unless-stopped
frontend:
build:
context: ./frontend
dockerfile: Dockerfile.dev
container_name: audio_classifier_ui_dev
environment:
NEXT_PUBLIC_API_URL: http://backend:8000
NODE_ENV: development
ports:
- "3000:3000"
volumes:
- ./frontend:/app
- /app/node_modules
depends_on:
- backend
restart: unless-stopped
volumes:
postgres_data:
driver: local

6
docker-compose.yml
View File

@@ -33,10 +33,8 @@ services:
ports: ports:
- "8001:8000" - "8001:8000"
volumes: volumes:
# Mount your audio library (read-only) # Mount your audio library (read-write for transcoding and waveforms)
- ${AUDIO_LIBRARY_PATH:-./audio_samples}:/audio:ro - ${AUDIO_LIBRARY_PATH:-./audio_samples}:/audio
# Mount models directory
- ./backend/models:/app/models
restart: unless-stopped restart: unless-stopped
frontend: frontend:

2
frontend/.env.local.example
View File

@@ -1 +1 @@
NEXT_PUBLIC_API_URL=http://localhost:8000 NEXT_PUBLIC_API_URL=http://localhost:8001

16
frontend/Dockerfile.dev
View File

@@ -1,16 +0,0 @@
FROM node:20-alpine
# Set working directory
WORKDIR /app
# Copy package files
COPY package*.json ./
# Install dependencies
RUN npm ci
# Expose port
EXPOSE 3000
# Start the development server
CMD ["npm", "run", "dev"]

71
frontend/app/page.tsx
View File

@@ -53,6 +53,8 @@ export default function Home() {
const [page, setPage] = useState(0) const [page, setPage] = useState(0)
const [currentTrack, setCurrentTrack] = useState<Track | null>(null) const [currentTrack, setCurrentTrack] = useState<Track | null>(null)
const [searchQuery, setSearchQuery] = useState("") const [searchQuery, setSearchQuery] = useState("")
const [isScanning, setIsScanning] = useState(false)
const [scanStatus, setScanStatus] = useState<string>("")
const limit = 25 const limit = 25
const { data: tracksData, isLoading: isLoadingTracks } = useQuery({ const { data: tracksData, isLoading: isLoadingTracks } = useQuery({
@@ -82,6 +84,49 @@ export default function Home() {
const totalPages = tracksData ? Math.ceil(tracksData.total / limit) : 0 const totalPages = tracksData ? Math.ceil(tracksData.total / limit) : 0
const handleRescan = async () => {
try {
setIsScanning(true)
setScanStatus("Démarrage du scan...")
const response = await fetch(`${process.env.NEXT_PUBLIC_API_URL}/api/library/scan`, {
method: 'POST',
})
if (!response.ok) {
throw new Error('Échec du démarrage du scan')
}
setScanStatus("Scan en cours...")
// Poll scan status
const pollInterval = setInterval(async () => {
try {
const statusResponse = await fetch(`${process.env.NEXT_PUBLIC_API_URL}/api/library/scan/status`)
const status = await statusResponse.json()
if (!status.is_scanning) {
clearInterval(pollInterval)
setScanStatus(`Scan terminé ! ${status.processed} fichiers traités`)
setIsScanning(false)
// Refresh tracks after scan
window.location.reload()
} else {
setScanStatus(`Scan : ${status.processed}/${status.total_files} fichiers (${status.progress}%)`)
}
} catch (error) {
console.error('Erreur lors de la vérification du statut:', error)
}
}, 2000)
} catch (error) {
console.error('Erreur lors du rescan:', error)
setScanStatus("Erreur lors du scan")
setIsScanning(false)
}
}
return ( return (
<div className="min-h-screen bg-gradient-to-br from-slate-50 to-slate-100 flex flex-col"> <div className="min-h-screen bg-gradient-to-br from-slate-50 to-slate-100 flex flex-col">
{/* Header */} {/* Header */}
@@ -109,8 +154,30 @@ export default function Home() {
</div> </div>
</div> </div>
<div className="ml-6 text-sm text-slate-600"> <div className="ml-6 flex items-center gap-3">
{tracksData?.total || 0} piste{(tracksData?.total || 0) > 1 ? 's' : ''} <div className="text-sm text-slate-600">
{tracksData?.total || 0} piste{(tracksData?.total || 0) > 1 ? 's' : ''}
</div>
{/* Rescan button */}
<button
onClick={handleRescan}
disabled={isScanning}
className="px-4 py-2 bg-orange-500 hover:bg-orange-600 disabled:bg-slate-300 disabled:cursor-not-allowed text-white text-sm font-medium rounded-lg transition-colors flex items-center gap-2"
title="Rescanner la bibliothèque musicale"
>
<svg className={`w-4 h-4 ${isScanning ? 'animate-spin' : ''}`} fill="none" stroke="currentColor" viewBox="0 0 24 24">
<path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M4 4v5h.582m15.356 2A8.001 8.001 0 004.582 9m0 0H9m11 11v-5h-.581m0 0a8.003 8.003 0 01-15.357-2m15.357 2H15" />
</svg>
{isScanning ? 'Scan en cours...' : 'Rescan'}
</button>
{/* Scan status */}
{scanStatus && (
<div className="text-xs text-slate-600 bg-slate-100 px-3 py-1 rounded">
{scanStatus}
</div>
)}
</div> </div>
</div> </div>
</div> </div>

73
scripts/download-essentia-models.sh
View File

@@ -1,73 +0,0 @@
#!/usr/bin/env bash
# Download Essentia models for audio classification
# Models from: https://essentia.upf.edu/models.html
set -e # Exit on error
MODELS_DIR="backend/models"
CLASS_HEADS_URL="https://essentia.upf.edu/models/classification-heads"
EMBEDDINGS_URL="https://essentia.upf.edu/models/feature-extractors/discogs-effnet"
echo "📦 Downloading Essentia models..."
echo "Models directory: $MODELS_DIR"
# Create models directory if it doesn't exist
mkdir -p "$MODELS_DIR"
# Download function
download_model() {
local model_file="$1"
local url="$2"
local output_path="$MODELS_DIR/$model_file"
if [ -f "$output_path" ]; then
echo "✓ $model_file already exists, skipping..."
else
echo "⬇️ Downloading $model_file..."
# Use -k flag to ignore SSL certificate issues with essentia.upf.edu
curl -k -L -o "$output_path" "$url"
if [ -f "$output_path" ] && [ -s "$output_path" ]; then
echo "✓ Downloaded $model_file ($(du -h "$output_path" | cut -f1))"
else
echo "✗ Failed to download $model_file"
rm -f "$output_path" # Remove empty/failed file
exit 1
fi
fi
}
# Download embedding model first (required for all classification heads)
echo ""
echo "Downloading embedding model..."
download_model "discogs-effnet-bs64-1.pb" \
"$EMBEDDINGS_URL/discogs-effnet-bs64-1.pb"
# Download classification heads
echo ""
echo "Downloading classification heads..."
# Genre: Discogs400 (professional taxonomy with 400 genres)
download_model "genre_discogs400-discogs-effnet-1.pb" \
"$CLASS_HEADS_URL/genre_discogs400/genre_discogs400-discogs-effnet-1.pb"
download_model "genre_discogs400-discogs-effnet-1.json" \
"$CLASS_HEADS_URL/genre_discogs400/genre_discogs400-discogs-effnet-1.json"
# Mood & Instrument: MTG-Jamendo
download_model "mtg_jamendo_moodtheme-discogs-effnet-1.pb" \
"$CLASS_HEADS_URL/mtg_jamendo_moodtheme/mtg_jamendo_moodtheme-discogs-effnet-1.pb"
download_model "mtg_jamendo_instrument-discogs-effnet-1.pb" \
"$CLASS_HEADS_URL/mtg_jamendo_instrument/mtg_jamendo_instrument-discogs-effnet-1.pb"
echo ""
echo "✅ All models downloaded successfully!"
echo ""
echo "Models available:"
ls -lh "$MODELS_DIR"/*.pb 2>/dev/null || echo "No .pb files found"
echo ""
echo "Note: Class labels are defined in backend/src/core/essentia_classifier.py"
echo "You can now start the backend with: docker-compose up"