chore: publish current ableton mcp ai workspace
This commit is contained in:
renato97
@@ -0,0 +1,39 @@
|
||||
# Abletunes Template Notes
|
||||
|
||||
Estos templates muestran patrones claros de produccion real que conviene copiar en el generador.
|
||||
|
||||
## Patrones fuertes
|
||||
|
||||
- Son `arrangement-first`, no `session-first`. En los cuatro sets los clips viven casi enteros en Arrangement y las scenes estan vacias o sin rol productivo.
|
||||
- Todos usan locators para secciones (`Intro`, `Breakdown`, `Drop`, `Break`, `Outro`, `End`) y esas secciones casi siempre caen en bloques de `16`, `32`, `64`, `96` o `128` beats.
|
||||
- Siempre hay jerarquia por grupos: drums/top drums, bass, instruments, vox, fx.
|
||||
- Casi siempre existe un `SC Trigger` o pista equivalente dedicada al sidechain.
|
||||
- Los drums no son una sola pista. Hay capas separadas para kick, clap, snare, hats, ride, perc, fills, crashes, risers y FX.
|
||||
- Las partes armonicas tampoco son una sola pista. Aparecen capas distintas para bassline, reese/sub, chord, piano, string, pluck, lead y layers.
|
||||
- Mezclan MIDI e audio de forma agresiva. Un productor no se queda solo con MIDI: imprime loops, resamples, freeze y audios procesados cuando hace falta.
|
||||
- Hay bastante tratamiento por pista: `Eq8`, `Compressor2`, `Reverb`, `AutoFilter`, `PingPongDelay`, `GlueCompressor`, `MultibandDynamics`, `Limiter`, `Saturator`.
|
||||
|
||||
## Lo que mas importa para el MCP
|
||||
|
||||
- El generador no tiene que crear "un loop largo". Tiene que crear secciones con mutaciones claras entre una y otra.
|
||||
- Cada seccion necesita variacion de densidad, no solo mute/unmute basico. Los templates meten fills, crashes, reverse FX, chants, top loops y capas extra solo en puntos de tension.
|
||||
- El arreglo profesional usa mas pistas especializadas de las que hoy genera el MCP. La separacion por rol es parte del sonido.
|
||||
- Hay que imprimir mas audio original derivado del propio proyecto: resamples, reverses, freezes y FX hechos a partir de material propio.
|
||||
- Los returns son pocos pero concretos. No hace falta llenar de sends; hace falta `reverb`, `delay` y buses de grupo bien usados.
|
||||
|
||||
## Señales concretas vistas en el pack
|
||||
|
||||
- `Abletunes - Dope As F_ck`: `128 BPM`, 6 grupos, 2 returns, `Sylenth1` dominante, mucha automatizacion (`8121` eventos).
|
||||
- `Abletunes - Freedom`: `126 BPM`, mezcla house mas simple, bateria muy separada, menos automatizacion, mucho `OriginalSimpler` + `Serum`.
|
||||
- `Abletunes - Hideout`: set largo y cargado, `Massive` + `Sylenth1`, una bateria enorme y mucha automatizacion (`6470` eventos).
|
||||
- `Abletunes - Nobody's Watching`: enfoque mas stock, usa `Operator`, `Simpler`, bastante audio vocal y FX impresos.
|
||||
|
||||
## Reglas que deberiamos incorporar
|
||||
|
||||
- Generar por defecto en Arrangement, con locators reales y secciones de 16/32 bars.
|
||||
- Añadir `SC Trigger`, grupos y returns fijos desde el blueprint.
|
||||
- Separar drums en mas roles: kick, clap main, clap layer, snare fill, hats, ride, perc main, perc FX, crash, reverse, riser.
|
||||
- Separar armonia y hooks: sub, bassline, chord stab, piano/keys, string/pad, pluck, lead, accent synth.
|
||||
- Crear eventos de transicion por seccion: uplifter, downlifter, reverse crash, vocal chop, tom fill.
|
||||
- Imprimir audio derivado del material generado cuando una capa necesite mas impacto o textura.
|
||||
- Meter automatizacion por seccion en filtros, sends, volumen de grupos y FX de transicion.
|
||||
255
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/API.md
Normal file
255
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/API.md
Normal file
@@ -0,0 +1,255 @@
|
||||
# AbletonMCP-AI API Documentation
|
||||
|
||||
## MCP Tools Disponibles
|
||||
|
||||
### Generación
|
||||
|
||||
#### `generate_song(genre, bpm, key, style, structure)`
|
||||
Genera un track completo con todas las capas de audio.
|
||||
|
||||
**Parámetros:**
|
||||
- `genre` (str): Género musical (techno, house, trance, etc)
|
||||
- `bpm` (float): BPM deseado (0 = auto)
|
||||
- `key` (str): Tonalidad (ej: "F#m", "Am")
|
||||
- `style` (str): Sub-estilo (industrial, deep, etc)
|
||||
- `structure` (str): Tipo de estructura (standard, minimal, extended)
|
||||
|
||||
**Ejemplo:**
|
||||
```python
|
||||
result = generate_song("techno", 138, "F#m", "industrial", "standard")
|
||||
```
|
||||
|
||||
#### `generate_with_human_feel(genre, bpm, key, humanize, groove_style)`
|
||||
Genera un track con humanización aplicada.
|
||||
|
||||
**Parámetros adicionales:**
|
||||
- `humanize` (bool): Aplicar variaciones de timing/velocity
|
||||
- `groove_style` (str): Tipo de groove (straight, shuffle, triplet, latin)
|
||||
|
||||
**Ejemplo:**
|
||||
```python
|
||||
result = generate_with_human_feel("house", 124, "Am", True, "shuffle")
|
||||
```
|
||||
|
||||
### Palette y Samples
|
||||
|
||||
#### `set_palette_lock(drums, bass, music)`
|
||||
Fuerza carpetas ancla específicas para la generación.
|
||||
|
||||
**Parámetros:**
|
||||
- `drums` (str): Path a carpeta de drums
|
||||
- `bass` (str): Path a carpeta de bass
|
||||
- `music` (str): Path a carpeta de music/synths
|
||||
|
||||
**Ejemplo:**
|
||||
```python
|
||||
set_palette_lock(
|
||||
drums="librerias/Kick Loops",
|
||||
bass="librerias/Bass Loops",
|
||||
music="librerias/Synth Loops"
|
||||
)
|
||||
```
|
||||
|
||||
#### `get_coverage_wheel_report()`
|
||||
Retorna heatmap de uso de carpetas de samples.
|
||||
|
||||
**Retorna:**
|
||||
- Lista de carpetas ordenadas por uso
|
||||
- Heat levels (FROZEN, COOL, WARM, HOT)
|
||||
- Sugerencias de carpetas bajo-usadas
|
||||
|
||||
#### `get_sample_fatigue_report()`
|
||||
Retorna reporte de fatiga de samples.
|
||||
|
||||
**Retorna:**
|
||||
- Top samples más usados
|
||||
- Factor de fatiga por rol
|
||||
- Thresholds de penalización
|
||||
|
||||
#### `reset_sample_fatigue(role)`
|
||||
Resetea la fatiga de samples.
|
||||
|
||||
**Parámetros:**
|
||||
- `role` (str, opcional): Si especificado, solo resetea ese rol
|
||||
|
||||
### Validación
|
||||
|
||||
#### `validate_set(check_routing, check_gain, check_clips)`
|
||||
Valida el set completo de Ableton.
|
||||
|
||||
**Checks:**
|
||||
- Routing de tracks
|
||||
- Niveles de gain staging
|
||||
- Clips vacíos
|
||||
- Conflictos armónicos
|
||||
|
||||
#### `validate_audio_layers()`
|
||||
Valida específicamente los tracks de audio.
|
||||
|
||||
#### `get_generation_manifest()`
|
||||
Retorna el manifest de la última generación.
|
||||
|
||||
### Memory y Diversidad
|
||||
|
||||
#### `reset_diversity_memory()`
|
||||
Limpia la memoria de diversidad entre generaciones.
|
||||
|
||||
#### `get_sample_coverage_report()`
|
||||
Retorna reporte de cobertura de samples usados.
|
||||
|
||||
## Engines de Procesamiento
|
||||
|
||||
### HumanFeelEngine
|
||||
|
||||
Aplica humanización a patrones MIDI.
|
||||
|
||||
```python
|
||||
from human_feel import HumanFeelEngine
|
||||
|
||||
engine = HumanFeelEngine(seed=42)
|
||||
notes = [{'pitch': 60, 'start': 0.0, 'velocity': 100}]
|
||||
|
||||
# Aplicar timing variation
|
||||
result = engine.apply_timing_variation(notes, amount_ms=5.0)
|
||||
|
||||
# Aplicar velocity humanize
|
||||
result = engine.apply_velocity_humanize(result, variance=0.05)
|
||||
|
||||
# Aplicar groove
|
||||
result = engine.apply_groove(result, style='shuffle', amount=0.5)
|
||||
|
||||
# Aplicar dinámica por sección
|
||||
result = engine.apply_section_dynamics(result, section='drop')
|
||||
```
|
||||
|
||||
### DJArrangementEngine
|
||||
|
||||
Genera estructuras DJ-friendly.
|
||||
|
||||
```python
|
||||
from audio_arrangement import DJArrangementEngine
|
||||
|
||||
engine = DJArrangementEngine(seed=42)
|
||||
|
||||
# Generar estructura
|
||||
structure = engine.generate_structure("standard")
|
||||
|
||||
# Verificar si es DJ-friendly
|
||||
is_friendly = engine.is_dj_friendly(structure)
|
||||
|
||||
# Generar curva de energía
|
||||
automation = engine.generate_energy_automation(structure)
|
||||
```
|
||||
|
||||
### SoundscapeEngine
|
||||
|
||||
Gestiona ambientes y texturas.
|
||||
|
||||
```python
|
||||
from audio_soundscape import SoundscapeEngine
|
||||
|
||||
engine = SoundscapeEngine()
|
||||
|
||||
# Detectar gaps
|
||||
gaps = engine.detect_ambience_gaps(timeline)
|
||||
|
||||
# Llenar con atmos
|
||||
atmos = engine.fill_with_atmos(gaps, genre="techno", key="F#m")
|
||||
```
|
||||
|
||||
### MasterChain
|
||||
|
||||
Configura cadena de mastering.
|
||||
|
||||
```python
|
||||
from audio_mastering import MasterChain, MasteringPreset
|
||||
|
||||
# Crear chain
|
||||
chain = MasterChain()
|
||||
|
||||
# Aplicar preset
|
||||
preset = MasteringPreset.get_preset("club")
|
||||
chain.set_limiter_ceiling(preset['ceiling'])
|
||||
|
||||
# Obtener chain para Ableton
|
||||
devices = chain.get_ableton_device_chain()
|
||||
```
|
||||
|
||||
### AutoPrompter
|
||||
|
||||
Genera configuraciones desde descripciones de vibe.
|
||||
|
||||
```python
|
||||
from self_ai import AutoPrompter
|
||||
|
||||
prompter = AutoPrompter()
|
||||
|
||||
# Generar desde vibe
|
||||
params = prompter.generate_from_vibe("dark warehouse techno")
|
||||
# Retorna: genre, bpm, key, style, structure
|
||||
```
|
||||
|
||||
## Pipeline Completo
|
||||
|
||||
```python
|
||||
from full_integration import generate_complete_track
|
||||
|
||||
# Generación completa con todas las fases
|
||||
track = generate_complete_track("deep house sunset", seed=42)
|
||||
|
||||
# El resultado incluye:
|
||||
# - vibe_params
|
||||
# - structure
|
||||
# - transitions
|
||||
# - atmos_events
|
||||
# - fx_events
|
||||
# - master_chain
|
||||
# - human_feel config
|
||||
```
|
||||
|
||||
## Sistema de Fatiga
|
||||
|
||||
El sistema de fatiga evita la repetición de samples:
|
||||
|
||||
- 0 usos: factor 1.0 (sin penalización)
|
||||
- 1-3 usos: factor 0.75
|
||||
- 4-10 usos: factor 0.50
|
||||
- 10+ usos: factor 0.20
|
||||
|
||||
## Palette Bonus
|
||||
|
||||
Sistema de scoring por compatibilidad de carpeta:
|
||||
|
||||
- Folder ancla exacto: 1.4x
|
||||
- Subfolder del ancla: 1.3x
|
||||
- Folder hermano (mismo padre): 1.2x
|
||||
- Folder diferente: 0.9x
|
||||
|
||||
## Testing
|
||||
|
||||
Ejecutar tests:
|
||||
|
||||
```bash
|
||||
cd AbletonMCP_AI/MCP_Server
|
||||
python -m unittest tests.test_sample_selector tests.test_human_feel tests.test_integration -v
|
||||
```
|
||||
|
||||
## Constantes Importantes
|
||||
|
||||
### Energy Profiles
|
||||
- intro: 30%
|
||||
- build: 70%
|
||||
- drop: 100%
|
||||
- break: 50%
|
||||
- outro: 20%
|
||||
|
||||
### Loudness Targets
|
||||
- streaming: -14 LUFS
|
||||
- club: -8 LUFS
|
||||
- safe: -12 LUFS
|
||||
|
||||
### Master Chain
|
||||
- Utility (gain staging)
|
||||
- Saturator (drive 1.5)
|
||||
- Compressor (ratio 2:1)
|
||||
- Limiter (ceiling -0.3dB)
|
||||
203
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/SAMPLE_SYSTEM_README.md
Normal file
203
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/SAMPLE_SYSTEM_README.md
Normal file
@@ -0,0 +1,203 @@
|
||||
# Sistema de Gestión de Samples - AbletonMCP-AI
|
||||
|
||||
Sistema completo de indexación, clasificación y selección inteligente de samples musicales.
|
||||
|
||||
## Componentes
|
||||
|
||||
### 1. `audio_analyzer.py` - Análisis de Audio
|
||||
|
||||
Detecta automáticamente características de archivos de audio:
|
||||
- **BPM**: Detección de tempo mediante análisis de onset
|
||||
- **Key**: Detección de tonalidad mediante cromagrama
|
||||
- **Tipo**: Clasificación en kick, snare, bass, synth, etc.
|
||||
- **Características espectrales**: Centroide, rolloff, RMS
|
||||
|
||||
**Uso básico:**
|
||||
```python
|
||||
from audio_analyzer import analyze_sample
|
||||
|
||||
result = analyze_sample("path/to/sample.wav")
|
||||
print(f"BPM: {result['bpm']}, Key: {result['key']}")
|
||||
print(f"Tipo: {result['sample_type']}")
|
||||
```
|
||||
|
||||
**Backends:**
|
||||
- `librosa`: Análisis completo (requiere instalación)
|
||||
- `basic`: Análisis por nombre de archivo (sin dependencias)
|
||||
|
||||
### 2. `sample_manager.py` - Gestión de Librería
|
||||
|
||||
Gestor completo de la librería de samples:
|
||||
- Indexación recursiva de directorios
|
||||
- Clasificación automática por categorías
|
||||
- Metadatos extensibles (tags, rating, géneros)
|
||||
- Búsqueda avanzada con múltiples filtros
|
||||
- Persistencia en JSON
|
||||
|
||||
**Categorías principales:**
|
||||
- `drums`: kick, snare, clap, hat, perc, shaker, tom, cymbal
|
||||
- `bass`: sub, bassline, acid
|
||||
- `synths`: lead, pad, pluck, chord, fx
|
||||
- `vocals`: vocal, speech, chant
|
||||
- `loops`: drum_loop, bass_loop, synth_loop, full_loop
|
||||
- `one_shots`: hit, noise
|
||||
|
||||
**Uso básico:**
|
||||
```python
|
||||
from sample_manager import SampleManager
|
||||
|
||||
# Inicializar
|
||||
manager = SampleManager(r"C:\Users\ren\embeddings\all_tracks")
|
||||
|
||||
# Escanear
|
||||
stats = manager.scan_directory(analyze_audio=True)
|
||||
|
||||
# Buscar
|
||||
kicks = manager.search(sample_type="kick", key="Am", bpm=128)
|
||||
house_samples = manager.search(genres=["house"], limit=10)
|
||||
|
||||
# Obtener pack completo
|
||||
pack = manager.get_pack_for_genre("techno", key="F#m", bpm=130)
|
||||
```
|
||||
|
||||
### 3. `sample_selector.py` - Selección Inteligente
|
||||
|
||||
Selección contextual basada en género, key y BPM:
|
||||
- Perfiles de género predefinidos
|
||||
- Matching armónico entre samples
|
||||
- Generación de kits de batería coherentes
|
||||
- Mapeo MIDI automático
|
||||
|
||||
**Géneros soportados:**
|
||||
- Techno (industrial, minimal, acid)
|
||||
- House (deep, classic, progressive)
|
||||
- Tech-House
|
||||
- Trance (progressive, psy)
|
||||
- Drum & Bass (liquid, neuro)
|
||||
- Ambient
|
||||
|
||||
**Uso básico:**
|
||||
```python
|
||||
from sample_selector import SampleSelector
|
||||
|
||||
selector = SampleSelector()
|
||||
|
||||
# Seleccionar para un género
|
||||
group = selector.select_for_genre("techno", key="F#m", bpm=130)
|
||||
|
||||
# Acceder a elementos
|
||||
group.drums.kick # Sample de kick
|
||||
group.bass # Lista de bass samples
|
||||
group.synths # Lista de synths
|
||||
|
||||
# Mapeo MIDI
|
||||
mapping = selector.get_midi_mapping_for_kit(group.drums)
|
||||
|
||||
# Cambio de key armónico
|
||||
new_key = selector.suggest_key_change("Am", "fifth_up") # Em
|
||||
```
|
||||
|
||||
## Integración con MCP Server
|
||||
|
||||
El servidor MCP expone las siguientes herramientas:
|
||||
|
||||
### Gestión de Librería
|
||||
- `scan_sample_library` - Escanear directorio de samples
|
||||
- `get_sample_library_stats` - Estadísticas de la librería
|
||||
|
||||
### Búsqueda y Selección
|
||||
- `advanced_search_samples` - Búsqueda con filtros múltiples
|
||||
- `select_samples_for_genre` - Selección automática por género
|
||||
- `get_drum_kit_mapping` - Kit de batería con mapeo MIDI
|
||||
- `get_sample_pack_for_project` - Pack completo para proyecto
|
||||
|
||||
### Análisis y Compatibilidad
|
||||
- `analyze_audio_file` - Analizar archivo de audio
|
||||
- `find_compatible_samples` - Encontrar samples compatibles
|
||||
- `suggest_key_change` - Sugerir cambios de tonalidad
|
||||
|
||||
## Estructura de Datos
|
||||
|
||||
### Sample
|
||||
```python
|
||||
@dataclass
|
||||
class Sample:
|
||||
id: str # ID único
|
||||
name: str # Nombre del archivo
|
||||
path: str # Ruta completa
|
||||
category: str # Categoría principal
|
||||
subcategory: str # Subcategoría
|
||||
sample_type: str # Tipo específico
|
||||
key: Optional[str] # Tonalidad (Am, F#m, C)
|
||||
bpm: Optional[float] # BPM
|
||||
duration: float # Duración en segundos
|
||||
genres: List[str] # Géneros asociados
|
||||
tags: List[str] # Tags
|
||||
rating: int # Rating 0-5
|
||||
```
|
||||
|
||||
### DrumKit
|
||||
```python
|
||||
@dataclass
|
||||
class DrumKit:
|
||||
name: str
|
||||
kick: Optional[Sample]
|
||||
snare: Optional[Sample]
|
||||
clap: Optional[Sample]
|
||||
hat_closed: Optional[Sample]
|
||||
hat_open: Optional[Sample]
|
||||
perc1: Optional[Sample]
|
||||
perc2: Optional[Sample]
|
||||
```
|
||||
|
||||
## Mapeo MIDI
|
||||
|
||||
Notas estándar para drums:
|
||||
- `36` (C1): Kick
|
||||
- `38` (D1): Snare
|
||||
- `39` (D#1): Clap
|
||||
- `42` (F#1): Closed Hat
|
||||
- `46` (A#1): Open Hat
|
||||
- `41` (F1): Tom Low
|
||||
- `49` (C#2): Crash
|
||||
|
||||
## Ejemplos de Uso
|
||||
|
||||
### Crear un track completo
|
||||
```python
|
||||
# Seleccionar samples para techno
|
||||
selector = get_selector()
|
||||
group = selector.select_for_genre("techno", key="F#m", bpm=130)
|
||||
|
||||
# Usar con Ableton
|
||||
ableton = get_ableton_connection()
|
||||
|
||||
# Crear tracks y cargar samples
|
||||
for i, sample in enumerate([group.drums.kick, group.drums.snare]):
|
||||
if sample:
|
||||
print(f"Cargar {sample.name} en track {i}")
|
||||
```
|
||||
|
||||
### Buscar samples compatibles
|
||||
```python
|
||||
# Encontrar samples que combinen con un kick
|
||||
kick = manager.get_by_path("path/to/kick.wav")
|
||||
compatible = selector.find_compatible_samples(kick, max_results=5)
|
||||
|
||||
for sample, score in compatible:
|
||||
print(f"{sample.name}: {score:.1%} compatible")
|
||||
```
|
||||
|
||||
## Archivos Generados
|
||||
|
||||
- `.sample_cache/sample_library.json` - Índice de la librería
|
||||
- `.sample_cache/library_stats.json` - Estadísticas
|
||||
|
||||
## Dependencias Opcionales
|
||||
|
||||
Para análisis de audio completo:
|
||||
```bash
|
||||
pip install librosa soundfile numpy
|
||||
```
|
||||
|
||||
Sin estas dependencias, el sistema funciona en modo "basic" usando metadatos de los nombres de archivo.
|
||||
26
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/__init__.py
Normal file
26
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/__init__.py
Normal file
@@ -0,0 +1,26 @@
|
||||
"""
|
||||
MCP Server para AbletonMCP-AI
|
||||
Servidor FastMCP que conecta Claude con Ableton Live 12
|
||||
"""
|
||||
|
||||
from .server import mcp, main
|
||||
from .song_generator import SongGenerator
|
||||
from .sample_index import SampleIndex
|
||||
|
||||
# Nuevo sistema de samples
|
||||
try:
|
||||
SAMPLE_SYSTEM_AVAILABLE = True
|
||||
except ImportError:
|
||||
SAMPLE_SYSTEM_AVAILABLE = False
|
||||
|
||||
__all__ = [
|
||||
'mcp', 'main',
|
||||
'SongGenerator', 'SampleIndex',
|
||||
]
|
||||
|
||||
if SAMPLE_SYSTEM_AVAILABLE:
|
||||
__all__.extend([
|
||||
'SampleManager', 'Sample', 'get_manager',
|
||||
'SampleSelector', 'get_selector', 'DrumKit', 'InstrumentGroup',
|
||||
'AudioAnalyzer', 'analyze_sample', 'SampleType',
|
||||
])
|
||||
681
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/audio_analyzer.py
Normal file
681
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/audio_analyzer.py
Normal file
@@ -0,0 +1,681 @@
|
||||
"""
|
||||
audio_analyzer.py - Análisis de audio para detección de Key y BPM
|
||||
|
||||
Proporciona análisis básico de archivos de audio para extraer:
|
||||
- BPM (tempo) mediante detección de onset y autocorrelación
|
||||
- Key (tonalidad) mediante análisis de cromagrama
|
||||
- Características espectrales para clasificación
|
||||
"""
|
||||
|
||||
import os
|
||||
import logging
|
||||
import numpy as np
|
||||
import subprocess
|
||||
from pathlib import Path
|
||||
from typing import Dict, Any, Optional, Tuple, List
|
||||
from dataclasses import dataclass
|
||||
from enum import Enum
|
||||
|
||||
logger = logging.getLogger("AudioAnalyzer")
|
||||
|
||||
# Constantes musicales
|
||||
NOTE_NAMES = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B']
|
||||
KEY_PROFILES = {
|
||||
# Perfiles de Krumhansl-Schmuckler para detección de tonalidad
|
||||
'major': [6.35, 2.23, 3.48, 2.33, 4.38, 4.09, 2.52, 5.19, 2.39, 3.66, 2.29, 2.88],
|
||||
'minor': [6.33, 2.68, 3.52, 5.38, 2.60, 3.53, 2.54, 4.75, 3.98, 2.69, 3.34, 3.17]
|
||||
}
|
||||
|
||||
CIRCLE_OF_FIFTHS_MAJOR = ['C', 'G', 'D', 'A', 'E', 'B', 'F#', 'C#', 'G#', 'D#', 'A#', 'F']
|
||||
CIRCLE_OF_FIFTHS_MINOR = ['Am', 'Em', 'Bm', 'F#m', 'C#m', 'G#m', 'D#m', 'A#m', 'Fm', 'Cm', 'Gm', 'Dm']
|
||||
|
||||
|
||||
class SampleType(Enum):
|
||||
"""Tipos de samples musicales"""
|
||||
KICK = "kick"
|
||||
SNARE = "snare"
|
||||
CLAP = "clap"
|
||||
HAT_CLOSED = "hat_closed"
|
||||
HAT_OPEN = "hat_open"
|
||||
HAT = "hat"
|
||||
PERC = "perc"
|
||||
SHAKER = "shaker"
|
||||
TOM = "tom"
|
||||
CRASH = "crash"
|
||||
RIDE = "ride"
|
||||
BASS = "bass"
|
||||
SYNTH = "synth"
|
||||
PAD = "pad"
|
||||
LEAD = "lead"
|
||||
PLUCK = "pluck"
|
||||
ARP = "arp"
|
||||
CHORD = "chord"
|
||||
STAB = "stab"
|
||||
VOCAL = "vocal"
|
||||
FX = "fx"
|
||||
LOOP = "loop"
|
||||
AMBIENCE = "ambience"
|
||||
UNKNOWN = "unknown"
|
||||
|
||||
|
||||
@dataclass
|
||||
class AudioFeatures:
|
||||
"""Características extraídas de un archivo de audio"""
|
||||
bpm: Optional[float]
|
||||
key: Optional[str]
|
||||
key_confidence: float
|
||||
duration: float
|
||||
sample_rate: int
|
||||
sample_type: SampleType
|
||||
spectral_centroid: float
|
||||
spectral_rolloff: float
|
||||
zero_crossing_rate: float
|
||||
rms_energy: float
|
||||
is_harmonic: bool
|
||||
is_percussive: bool
|
||||
suggested_genres: List[str]
|
||||
|
||||
|
||||
class AudioAnalyzer:
|
||||
"""
|
||||
Analizador de audio para samples musicales.
|
||||
|
||||
Soporta múltiples backends:
|
||||
- librosa (recomendado, más preciso)
|
||||
- basic (fallback sin dependencias externas, basado en nombre de archivo)
|
||||
"""
|
||||
|
||||
def __init__(self, backend: str = "auto"):
|
||||
"""
|
||||
Inicializa el analizador de audio.
|
||||
|
||||
Args:
|
||||
backend: 'librosa', 'basic', o 'auto' (detecta automáticamente)
|
||||
"""
|
||||
self.backend = backend
|
||||
self._librosa_available = False
|
||||
self._soundfile_available = False
|
||||
|
||||
if backend in ("auto", "librosa"):
|
||||
self._check_librosa()
|
||||
|
||||
if self._librosa_available:
|
||||
logger.info("Usando backend: librosa")
|
||||
else:
|
||||
logger.info("Usando backend: basic (análisis por nombre de archivo)")
|
||||
|
||||
def _check_librosa(self):
|
||||
"""Verifica si librosa está disponible"""
|
||||
try:
|
||||
import librosa
|
||||
import soundfile as sf
|
||||
self._librosa_available = True
|
||||
self._soundfile_available = True
|
||||
self.librosa = librosa
|
||||
self.sf = sf
|
||||
except ImportError:
|
||||
self._librosa_available = False
|
||||
self._soundfile_available = False
|
||||
|
||||
def analyze(self, file_path: str) -> AudioFeatures:
|
||||
"""
|
||||
Analiza un archivo de audio y extrae características.
|
||||
|
||||
Args:
|
||||
file_path: Ruta al archivo de audio
|
||||
|
||||
Returns:
|
||||
AudioFeatures con los datos extraídos
|
||||
"""
|
||||
path = Path(file_path)
|
||||
|
||||
if not path.exists():
|
||||
raise FileNotFoundError(f"Archivo no encontrado: {file_path}")
|
||||
|
||||
# Intentar análisis con librosa si está disponible
|
||||
if self._librosa_available:
|
||||
try:
|
||||
return self._analyze_with_librosa(file_path)
|
||||
except Exception as e:
|
||||
logger.warning(f"Error con librosa: {e}, usando análisis básico")
|
||||
|
||||
# Fallback a análisis básico
|
||||
return self._analyze_basic(file_path)
|
||||
|
||||
def _analyze_with_librosa(self, file_path: str) -> AudioFeatures:
|
||||
"""Análisis completo usando librosa"""
|
||||
# Cargar audio
|
||||
y, sr = self.librosa.load(file_path, sr=None, mono=True)
|
||||
|
||||
# Duración
|
||||
duration = self.librosa.get_duration(y=y, sr=sr)
|
||||
|
||||
# Detectar BPM
|
||||
tempo, _ = self.librosa.beat.beat_track(y=y, sr=sr)
|
||||
bpm = float(tempo) if isinstance(tempo, (int, float, np.number)) else None
|
||||
|
||||
# Análisis espectral
|
||||
spectral_centroids = self.librosa.feature.spectral_centroid(y=y, sr=sr)[0]
|
||||
spectral_rolloffs = self.librosa.feature.spectral_rolloff(y=y, sr=sr)[0]
|
||||
zcr = self.librosa.feature.zero_crossing_rate(y)[0]
|
||||
rms = self.librosa.feature.rms(y=y)[0]
|
||||
|
||||
# Detectar key
|
||||
key, key_confidence = self._detect_key_librosa(y, sr)
|
||||
|
||||
# Clasificación percusivo vs armónico
|
||||
is_percussive = self._is_percussive(y, sr)
|
||||
is_harmonic = not is_percussive and duration > 1.0
|
||||
|
||||
# Determinar tipo de sample
|
||||
sample_type = self._classify_sample_type(
|
||||
file_path, is_percussive, is_harmonic, duration,
|
||||
float(np.mean(spectral_centroids)), float(np.mean(rms))
|
||||
)
|
||||
|
||||
# Sugerir géneros
|
||||
suggested_genres = self._suggest_genres(sample_type, bpm, key)
|
||||
|
||||
return AudioFeatures(
|
||||
bpm=bpm,
|
||||
key=key,
|
||||
key_confidence=key_confidence,
|
||||
duration=duration,
|
||||
sample_rate=sr,
|
||||
sample_type=sample_type,
|
||||
spectral_centroid=float(np.mean(spectral_centroids)),
|
||||
spectral_rolloff=float(np.mean(spectral_rolloffs)),
|
||||
zero_crossing_rate=float(np.mean(zcr)),
|
||||
rms_energy=float(np.mean(rms)),
|
||||
is_harmonic=is_harmonic,
|
||||
is_percussive=is_percussive,
|
||||
suggested_genres=suggested_genres
|
||||
)
|
||||
|
||||
def _detect_key_librosa(self, y: np.ndarray, sr: int) -> Tuple[Optional[str], float]:
|
||||
"""
|
||||
Detecta la tonalidad usando cromagrama y correlación con perfiles.
|
||||
"""
|
||||
try:
|
||||
# Calcular cromagrama
|
||||
chroma = self.librosa.feature.chroma_stft(y=y, sr=sr)
|
||||
chroma_avg = np.mean(chroma, axis=1)
|
||||
|
||||
# Normalizar
|
||||
chroma_avg = chroma_avg / (np.sum(chroma_avg) + 1e-10)
|
||||
|
||||
best_key = None
|
||||
best_score = -np.inf
|
||||
best_mode = None
|
||||
|
||||
# Probar todas las tonalidades mayores y menores
|
||||
for mode, profile in KEY_PROFILES.items():
|
||||
for i in range(12):
|
||||
# Rotar el perfil
|
||||
rotated_profile = np.roll(profile, i)
|
||||
# Correlación
|
||||
score = np.corrcoef(chroma_avg, rotated_profile)[0, 1]
|
||||
|
||||
if score > best_score:
|
||||
best_score = score
|
||||
best_mode = mode
|
||||
best_key = NOTE_NAMES[i]
|
||||
|
||||
# Formatear resultado
|
||||
if best_key:
|
||||
if best_mode == 'minor':
|
||||
best_key = best_key + 'm'
|
||||
confidence = max(0.0, min(1.0, (best_score + 1) / 2))
|
||||
return best_key, confidence
|
||||
|
||||
except Exception as e:
|
||||
logger.warning(f"Error detectando key: {e}")
|
||||
|
||||
return None, 0.0
|
||||
|
||||
def _is_percussive(self, y: np.ndarray, sr: int) -> bool:
|
||||
"""
|
||||
Determina si un sonido es principalmente percusivo.
|
||||
"""
|
||||
try:
|
||||
# Separar componentes armónicos y percusivos
|
||||
y_harmonic, y_percussive = self.librosa.effects.hpss(y)
|
||||
|
||||
# Calcular energía relativa
|
||||
energy_harmonic = np.sum(y_harmonic ** 2)
|
||||
energy_percussive = np.sum(y_percussive ** 2)
|
||||
total_energy = energy_harmonic + energy_percussive
|
||||
|
||||
if total_energy > 0:
|
||||
percussive_ratio = energy_percussive / total_energy
|
||||
return percussive_ratio > 0.6
|
||||
|
||||
except Exception as e:
|
||||
logger.warning(f"Error en separación HPSS: {e}")
|
||||
|
||||
# Fallback: usar duración como heurística
|
||||
duration = len(y) / sr
|
||||
return duration < 0.5
|
||||
|
||||
def _analyze_basic(self, file_path: str) -> AudioFeatures:
|
||||
"""
|
||||
Análisis básico sin dependencias externas.
|
||||
Usa metadatos del archivo y nombre para inferir características.
|
||||
"""
|
||||
path = Path(file_path)
|
||||
name = path.stem
|
||||
|
||||
# Extraer del nombre
|
||||
bpm = self._extract_bpm_from_name(name)
|
||||
key = self._extract_key_from_name(name)
|
||||
|
||||
# Estimar duración del archivo
|
||||
duration = self._estimate_duration(file_path)
|
||||
|
||||
# Clasificar por nombre
|
||||
sample_type = self._classify_by_name(name)
|
||||
|
||||
# Determinar características por tipo
|
||||
is_percussive = sample_type in [
|
||||
SampleType.KICK, SampleType.SNARE, SampleType.CLAP,
|
||||
SampleType.HAT, SampleType.HAT_CLOSED, SampleType.HAT_OPEN,
|
||||
SampleType.PERC, SampleType.SHAKER, SampleType.TOM,
|
||||
SampleType.CRASH, SampleType.RIDE
|
||||
]
|
||||
is_harmonic = sample_type in [
|
||||
SampleType.BASS, SampleType.SYNTH, SampleType.PAD,
|
||||
SampleType.LEAD, SampleType.PLUCK, SampleType.CHORD,
|
||||
SampleType.VOCAL
|
||||
]
|
||||
|
||||
# Valores por defecto basados en tipo
|
||||
spectral_centroid = 5000.0 if is_percussive else 1000.0
|
||||
rms_energy = 0.5
|
||||
|
||||
suggested_genres = self._suggest_genres(sample_type, bpm, key)
|
||||
|
||||
return AudioFeatures(
|
||||
bpm=bpm,
|
||||
key=key,
|
||||
key_confidence=0.7 if key else 0.0,
|
||||
duration=duration,
|
||||
sample_rate=44100,
|
||||
sample_type=sample_type,
|
||||
spectral_centroid=spectral_centroid,
|
||||
spectral_rolloff=spectral_centroid * 2,
|
||||
zero_crossing_rate=0.1 if is_harmonic else 0.3,
|
||||
rms_energy=rms_energy,
|
||||
is_harmonic=is_harmonic,
|
||||
is_percussive=is_percussive,
|
||||
suggested_genres=suggested_genres
|
||||
)
|
||||
|
||||
def _estimate_duration(self, file_path: str) -> float:
|
||||
"""Estima la duración del archivo de audio"""
|
||||
try:
|
||||
import wave
|
||||
|
||||
ext = Path(file_path).suffix.lower()
|
||||
|
||||
if ext == '.wav':
|
||||
with wave.open(file_path, 'rb') as wav:
|
||||
frames = wav.getnframes()
|
||||
rate = wav.getframerate()
|
||||
return frames / float(rate)
|
||||
|
||||
elif ext in ('.mp3', '.ogg', '.flac', '.aif', '.aiff', '.m4a'):
|
||||
windows_duration = self._estimate_duration_with_windows_shell(file_path)
|
||||
if windows_duration > 0:
|
||||
return windows_duration
|
||||
# Estimación por tamaño de archivo
|
||||
size = os.path.getsize(file_path)
|
||||
# Aproximación: ~176KB por segundo para CD quality stereo
|
||||
return size / (176.4 * 1024)
|
||||
|
||||
except Exception as e:
|
||||
logger.warning(f"Error estimando duración: {e}")
|
||||
|
||||
return 0.0
|
||||
|
||||
def _estimate_duration_with_windows_shell(self, file_path: str) -> float:
|
||||
"""Obtiene la duración usando metadatos del shell de Windows cuando están disponibles."""
|
||||
if os.name != 'nt':
|
||||
return 0.0
|
||||
|
||||
safe_path = file_path.replace("'", "''")
|
||||
powershell_command = (
|
||||
f"$path = '{safe_path}'; "
|
||||
"$shell = New-Object -ComObject Shell.Application; "
|
||||
"$folder = $shell.Namespace((Split-Path $path)); "
|
||||
"$file = $folder.ParseName((Split-Path $path -Leaf)); "
|
||||
"$duration = $folder.GetDetailsOf($file, 27); "
|
||||
"Write-Output $duration"
|
||||
)
|
||||
try:
|
||||
result = subprocess.run(
|
||||
f'powershell -NoProfile -Command "{powershell_command}"',
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=5,
|
||||
check=False,
|
||||
shell=True,
|
||||
)
|
||||
value = (result.stdout or "").strip()
|
||||
if not value:
|
||||
return 0.0
|
||||
parts = value.split(':')
|
||||
if len(parts) == 3:
|
||||
return (int(parts[0]) * 3600) + (int(parts[1]) * 60) + float(parts[2])
|
||||
return 0.0
|
||||
except Exception:
|
||||
return 0.0
|
||||
|
||||
def _extract_bpm_from_name(self, name: str) -> Optional[float]:
|
||||
"""Extrae BPM del nombre del archivo"""
|
||||
import re
|
||||
|
||||
patterns = [
|
||||
r'[_\s\-](\d{2,3})\s*BPM',
|
||||
r'[_\s\-](\d{2,3})[_\s\-]',
|
||||
r'(\d{2,3})bpm',
|
||||
r'[_\s\-](\d{2,3})\s*(?:BPM|bpm)?\s*(?:\.wav|\.mp3|\.aif)',
|
||||
]
|
||||
|
||||
for pattern in patterns:
|
||||
match = re.search(pattern, name, re.IGNORECASE)
|
||||
if match:
|
||||
bpm = int(match.group(1))
|
||||
if 60 <= bpm <= 200:
|
||||
return float(bpm)
|
||||
|
||||
return None
|
||||
|
||||
def _extract_key_from_name(self, name: str) -> Optional[str]:
|
||||
"""Extrae key del nombre del archivo"""
|
||||
import re
|
||||
|
||||
patterns = [
|
||||
r'[_\s\-]([A-G][#b]?(?:m|min|minor)?)[_\s\-]',
|
||||
r'\bin\s+([A-G][#b]?(?:m|min|minor)?)\b',
|
||||
r'Key\s+([A-G][#b]?(?:m|min|minor)?)',
|
||||
r'[_\s\-]([A-G][#b]?)\s*(?:maj|major)?[_\s\-]',
|
||||
]
|
||||
|
||||
for pattern in patterns:
|
||||
match = re.search(pattern, name, re.IGNORECASE)
|
||||
if match:
|
||||
key = match.group(1)
|
||||
# Normalizar
|
||||
key = key.replace('b', '#').replace('Db', 'C#').replace('Eb', 'D#')
|
||||
key = key.replace('Gb', 'F#').replace('Ab', 'G#').replace('Bb', 'A#')
|
||||
|
||||
# Detectar si es menor
|
||||
is_minor = 'm' in key.lower() or 'min' in key.lower()
|
||||
key = key.replace('min', '').replace('minor', '').replace('major', '')
|
||||
key = key.rstrip('mM')
|
||||
|
||||
if is_minor:
|
||||
key = key + 'm'
|
||||
|
||||
return key
|
||||
|
||||
return None
|
||||
|
||||
def _classify_sample_type(self, file_path: str, is_percussive: bool,
|
||||
is_harmonic: bool, duration: float,
|
||||
spectral_centroid: float, rms: float) -> SampleType:
|
||||
"""Clasifica el tipo de sample basado en características"""
|
||||
# Primero intentar por nombre
|
||||
sample_type = self._classify_by_name(Path(file_path).stem)
|
||||
if sample_type != SampleType.UNKNOWN:
|
||||
return sample_type
|
||||
|
||||
# Clasificación por características de audio
|
||||
if is_percussive:
|
||||
if duration < 0.1:
|
||||
if spectral_centroid < 2000:
|
||||
return SampleType.KICK
|
||||
elif spectral_centroid > 8000:
|
||||
return SampleType.HAT_CLOSED
|
||||
else:
|
||||
return SampleType.SNARE
|
||||
elif duration < 0.3:
|
||||
return SampleType.CLAP
|
||||
else:
|
||||
return SampleType.PERC
|
||||
|
||||
elif is_harmonic:
|
||||
if spectral_centroid < 500:
|
||||
return SampleType.BASS
|
||||
elif duration > 4.0:
|
||||
return SampleType.PAD
|
||||
else:
|
||||
return SampleType.SYNTH
|
||||
|
||||
return SampleType.UNKNOWN
|
||||
|
||||
def _classify_by_name(self, name: str) -> SampleType:
|
||||
"""Clasifica el tipo de sample basado en su nombre"""
|
||||
name_lower = name.lower()
|
||||
|
||||
# Mapeo de palabras clave a tipos
|
||||
keywords = {
|
||||
SampleType.KICK: ['kick', 'bd', 'bass drum', 'kickdrum', 'kik'],
|
||||
SampleType.SNARE: ['snare', 'snr', 'sd', 'rim'],
|
||||
SampleType.CLAP: ['clap', 'clp', 'handclap'],
|
||||
SampleType.HAT_CLOSED: ['closed hat', 'closedhat', 'chh', 'closed'],
|
||||
SampleType.HAT_OPEN: ['open hat', 'openhat', 'ohh', 'open'],
|
||||
SampleType.HAT: ['hat', 'hihat', 'hi-hat', 'hh'],
|
||||
SampleType.PERC: ['perc', 'percussion', 'conga', 'bongo', 'timb'],
|
||||
SampleType.SHAKER: ['shaker', 'shake', 'tamb'],
|
||||
SampleType.TOM: ['tom', 'tomtom'],
|
||||
SampleType.CRASH: ['crash', 'cymbal'],
|
||||
SampleType.RIDE: ['ride'],
|
||||
SampleType.BASS: ['bass', 'bassline', 'sub', '808', 'reese'],
|
||||
SampleType.SYNTH: ['synth', 'lead', 'arp', 'sequence'],
|
||||
SampleType.PAD: ['pad', 'atmosphere', 'dron'],
|
||||
SampleType.PLUCK: ['pluck'],
|
||||
SampleType.CHORD: ['chord', 'stab'],
|
||||
SampleType.VOCAL: ['vocal', 'vox', 'voice', 'speech', 'talk'],
|
||||
SampleType.FX: ['fx', 'effect', 'sweep', 'riser', 'downlifter', 'impact', 'hit', 'noise'],
|
||||
SampleType.LOOP: ['loop', 'full', 'groove'],
|
||||
}
|
||||
|
||||
for sample_type, words in keywords.items():
|
||||
for word in words:
|
||||
if word in name_lower:
|
||||
return sample_type
|
||||
|
||||
return SampleType.UNKNOWN
|
||||
|
||||
def _suggest_genres(self, sample_type: SampleType, bpm: Optional[float],
|
||||
key: Optional[str]) -> List[str]:
|
||||
"""Sugiere géneros musicales apropiados para el sample"""
|
||||
genres = []
|
||||
|
||||
if bpm:
|
||||
if 118 <= bpm <= 128:
|
||||
genres.extend(['house', 'tech-house', 'deep-house'])
|
||||
elif 124 <= bpm <= 132:
|
||||
genres.extend(['tech-house', 'techno'])
|
||||
elif 132 <= bpm <= 142:
|
||||
genres.extend(['techno', 'peak-time-techno'])
|
||||
elif 142 <= bpm <= 150:
|
||||
genres.extend(['trance', 'hard-techno'])
|
||||
elif 160 <= bpm <= 180:
|
||||
genres.extend(['drum-and-bass', 'neurofunk'])
|
||||
elif bpm < 118:
|
||||
genres.extend(['downtempo', 'ambient', 'lo-fi'])
|
||||
|
||||
# Por tipo de sample
|
||||
if sample_type in [SampleType.KICK, SampleType.SNARE, SampleType.CLAP]:
|
||||
if not genres:
|
||||
genres = ['techno', 'house']
|
||||
elif sample_type == SampleType.BASS:
|
||||
if not genres:
|
||||
genres = ['techno', 'house', 'bass-music']
|
||||
elif sample_type in [SampleType.SYNTH, SampleType.PAD]:
|
||||
if not genres:
|
||||
genres = ['trance', 'progressive', 'ambient']
|
||||
|
||||
return genres if genres else ['electronic']
|
||||
|
||||
def get_compatible_key(self, key: str, shift: int = 0) -> str:
|
||||
"""
|
||||
Obtiene una key compatible usando el círculo de quintas.
|
||||
|
||||
Args:
|
||||
key: Key original (ej: 'Am', 'F#m')
|
||||
shift: Desplazamiento en el círculo (+1 = quinta arriba, -1 = quinta abajo)
|
||||
|
||||
Returns:
|
||||
Key resultante
|
||||
"""
|
||||
is_minor = key.endswith('m')
|
||||
root = key.rstrip('m')
|
||||
|
||||
if root not in NOTE_NAMES:
|
||||
return key
|
||||
|
||||
circle = CIRCLE_OF_FIFTHS_MINOR if is_minor else CIRCLE_OF_FIFTHS_MAJOR
|
||||
|
||||
try:
|
||||
idx = circle.index(key)
|
||||
new_idx = (idx + shift) % 12
|
||||
return circle[new_idx]
|
||||
except ValueError:
|
||||
return key
|
||||
|
||||
def calculate_key_compatibility(self, key1: str, key2: str) -> float:
|
||||
"""
|
||||
Calcula la compatibilidad entre dos keys (0-1).
|
||||
|
||||
Usa el círculo de quintas: keys cercanas son más compatibles.
|
||||
"""
|
||||
if key1 == key2:
|
||||
return 1.0
|
||||
|
||||
# Normalizar
|
||||
def normalize(k):
|
||||
is_minor = k.endswith('m')
|
||||
root = k.rstrip('m')
|
||||
# Convertir bemoles a sostenidos
|
||||
root = root.replace('Db', 'C#').replace('Eb', 'D#')
|
||||
root = root.replace('Gb', 'F#').replace('Ab', 'G#').replace('Bb', 'A#')
|
||||
return root + ('m' if is_minor else '')
|
||||
|
||||
k1 = normalize(key1)
|
||||
k2 = normalize(key2)
|
||||
|
||||
if k1 == k2:
|
||||
return 1.0
|
||||
|
||||
# Verificar si son modos diferentes de la misma nota
|
||||
if k1.rstrip('m') == k2.rstrip('m'):
|
||||
return 0.8 # Mismo root, diferente modo
|
||||
|
||||
# Usar círculo de quintas
|
||||
is_minor1 = k1.endswith('m')
|
||||
is_minor2 = k2.endswith('m')
|
||||
|
||||
if is_minor1 != is_minor2:
|
||||
return 0.3 # Diferente modo, baja compatibilidad
|
||||
|
||||
circle = CIRCLE_OF_FIFTHS_MINOR if is_minor1 else CIRCLE_OF_FIFTHS_MAJOR
|
||||
|
||||
try:
|
||||
idx1 = circle.index(k1)
|
||||
idx2 = circle.index(k2)
|
||||
distance = min(abs(idx1 - idx2), 12 - abs(idx1 - idx2))
|
||||
|
||||
# Compatibilidad decrece con la distancia
|
||||
compatibility = max(0.0, 1.0 - (distance * 0.2))
|
||||
return compatibility
|
||||
|
||||
except ValueError:
|
||||
return 0.0
|
||||
|
||||
|
||||
# Instancia global
|
||||
_analyzer: Optional[AudioAnalyzer] = None
|
||||
|
||||
|
||||
def get_analyzer() -> AudioAnalyzer:
|
||||
"""Obtiene la instancia global del analizador"""
|
||||
global _analyzer
|
||||
if _analyzer is None:
|
||||
_analyzer = AudioAnalyzer()
|
||||
return _analyzer
|
||||
|
||||
|
||||
def analyze_sample(file_path: str) -> Dict[str, Any]:
|
||||
"""
|
||||
Función de conveniencia para analizar un sample.
|
||||
|
||||
Returns:
|
||||
Diccionario con las características del sample
|
||||
"""
|
||||
analyzer = get_analyzer()
|
||||
features = analyzer.analyze(file_path)
|
||||
|
||||
return {
|
||||
'bpm': features.bpm,
|
||||
'key': features.key,
|
||||
'key_confidence': features.key_confidence,
|
||||
'duration': features.duration,
|
||||
'sample_rate': features.sample_rate,
|
||||
'sample_type': features.sample_type.value,
|
||||
'spectral_centroid': features.spectral_centroid,
|
||||
'rms_energy': features.rms_energy,
|
||||
'is_harmonic': features.is_harmonic,
|
||||
'is_percussive': features.is_percussive,
|
||||
'suggested_genres': features.suggested_genres,
|
||||
}
|
||||
|
||||
|
||||
def quick_analyze(file_path: str) -> Dict[str, Any]:
|
||||
"""
|
||||
Análisis rápido basado solo en el nombre del archivo.
|
||||
No requiere dependencias externas.
|
||||
"""
|
||||
analyzer = AudioAnalyzer(backend="basic")
|
||||
features = analyzer.analyze(file_path)
|
||||
|
||||
return {
|
||||
'bpm': features.bpm,
|
||||
'key': features.key,
|
||||
'sample_type': features.sample_type.value,
|
||||
'suggested_genres': features.suggested_genres,
|
||||
}
|
||||
|
||||
|
||||
# Testing
|
||||
if __name__ == "__main__":
|
||||
import sys
|
||||
|
||||
logging.basicConfig(level=logging.INFO)
|
||||
|
||||
if len(sys.argv) < 2:
|
||||
print("Uso: python audio_analyzer.py <archivo_de_audio>")
|
||||
sys.exit(1)
|
||||
|
||||
file_path = sys.argv[1]
|
||||
|
||||
print(f"\nAnalizando: {file_path}")
|
||||
print("=" * 50)
|
||||
|
||||
try:
|
||||
result = analyze_sample(file_path)
|
||||
|
||||
print("\nResultados:")
|
||||
print(f" BPM: {result['bpm'] or 'No detectado'}")
|
||||
print(f" Key: {result['key'] or 'No detectado'} (confianza: {result['key_confidence']:.2f})")
|
||||
print(f" Duración: {result['duration']:.2f}s")
|
||||
print(f" Tipo: {result['sample_type']}")
|
||||
print(f" Géneros sugeridos: {', '.join(result['suggested_genres'])}")
|
||||
print(f" Es percusivo: {result['is_percussive']}")
|
||||
print(f" Es armónico: {result['is_harmonic']}")
|
||||
|
||||
except Exception as e:
|
||||
print(f"Error: {e}")
|
||||
sys.exit(1)
|
||||
197
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/audio_arrangement.py
Normal file
197
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/audio_arrangement.py
Normal file
@@ -0,0 +1,197 @@
|
||||
"""
|
||||
audio_arrangement.py - DJ Arrangement y Estructura
|
||||
T063-T077: Song Structure, Energy Curve, Transitions
|
||||
"""
|
||||
import random
|
||||
import logging
|
||||
from typing import List, Dict, Any, Optional
|
||||
from dataclasses import dataclass
|
||||
|
||||
logger = logging.getLogger("AudioArrangement")
|
||||
|
||||
|
||||
@dataclass
|
||||
class Section:
|
||||
"""Representa una sección musical"""
|
||||
name: str
|
||||
kind: str # intro, build, drop, break, outro
|
||||
bars: int
|
||||
energy: float # 0.0 - 1.0
|
||||
|
||||
|
||||
class DJArrangementEngine:
|
||||
"""T063-T077: Engine de estructuras DJ-friendly"""
|
||||
|
||||
# Energy levels por tipo de sección
|
||||
ENERGY_PROFILES = {
|
||||
'intro': 0.30,
|
||||
'build': 0.70,
|
||||
'drop': 1.00,
|
||||
'break': 0.50,
|
||||
'outro': 0.20,
|
||||
}
|
||||
|
||||
def __init__(self, seed: int = 42):
|
||||
self.rng = random.Random(seed)
|
||||
|
||||
def generate_structure(self, structure_type: str = "standard") -> List[Section]:
|
||||
"""
|
||||
T063-T066: Genera estructura de canción.
|
||||
|
||||
- standard: 64 bars (Intro 16, Build 16, Drop 16, Break 16, Drop 16, Outro 16)
|
||||
- minimal: 48 bars (Intro 8, Build 8, Drop 16, Break 8, Drop 8, Outro 8)
|
||||
- extended: 128 bars con A/B drop alternation
|
||||
"""
|
||||
if structure_type == "minimal":
|
||||
return [
|
||||
Section("Intro", "intro", 8, self.ENERGY_PROFILES['intro']),
|
||||
Section("Build 1", "build", 8, self.ENERGY_PROFILES['build']),
|
||||
Section("Drop A", "drop", 16, self.ENERGY_PROFILES['drop']),
|
||||
Section("Break", "break", 8, self.ENERGY_PROFILES['break']),
|
||||
Section("Drop B", "drop", 8, self.ENERGY_PROFILES['drop']),
|
||||
Section("Outro", "outro", 8, self.ENERGY_PROFILES['outro']),
|
||||
]
|
||||
elif structure_type == "extended":
|
||||
return [
|
||||
Section("Intro", "intro", 16, self.ENERGY_PROFILES['intro']),
|
||||
Section("Build 1", "build", 16, self.ENERGY_PROFILES['build']),
|
||||
Section("Drop A", "drop", 16, self.ENERGY_PROFILES['drop']),
|
||||
Section("Break 1", "break", 16, self.ENERGY_PROFILES['break']),
|
||||
Section("Build 2", "build", 16, self.ENERGY_PROFILES['build']),
|
||||
Section("Drop B", "drop", 16, self.ENERGY_PROFILES['drop']),
|
||||
Section("Break 2", "break", 16, self.ENERGY_PROFILES['break']),
|
||||
Section("Build 3", "build", 16, self.ENERGY_PROFILES['build']),
|
||||
Section("Drop C", "drop", 16, self.ENERGY_PROFILES['drop']),
|
||||
Section("Outro", "outro", 16, self.ENERGY_PROFILES['outro']),
|
||||
]
|
||||
else: # standard
|
||||
return [
|
||||
Section("Intro", "intro", 16, self.ENERGY_PROFILES['intro']),
|
||||
Section("Build 1", "build", 16, self.ENERGY_PROFILES['build']),
|
||||
Section("Drop A", "drop", 16, self.ENERGY_PROFILES['drop']),
|
||||
Section("Break", "break", 16, self.ENERGY_PROFILES['break']),
|
||||
Section("Drop B", "drop", 16, self.ENERGY_PROFILES['drop']),
|
||||
Section("Outro", "outro", 16, self.ENERGY_PROFILES['outro']),
|
||||
]
|
||||
|
||||
def is_dj_friendly(self, structure: List[Section]) -> bool:
|
||||
"""Verifica si la estructura es DJ-friendly (intro/outro ≥16 beats)."""
|
||||
if not structure:
|
||||
return False
|
||||
intro = structure[0]
|
||||
outro = structure[-1]
|
||||
# 16 bars = 64 beats
|
||||
return intro.bars >= 4 and outro.bars >= 4
|
||||
|
||||
def get_energy_at_position(self, structure: List[Section], bar: int) -> float:
|
||||
"""T067-T070: Retorna nivel de energía en posición específica."""
|
||||
current_bar = 0
|
||||
for section in structure:
|
||||
if current_bar <= bar < current_bar + section.bars:
|
||||
return section.energy
|
||||
current_bar += section.bars
|
||||
return 0.0
|
||||
|
||||
def generate_energy_automation(self, structure: List[Section]) -> List[Dict]:
|
||||
"""Genera curva de automatización de energía."""
|
||||
automation = []
|
||||
current_bar = 0
|
||||
for section in structure:
|
||||
automation.append({
|
||||
'bar': current_bar,
|
||||
'energy': section.energy,
|
||||
'section': section.name
|
||||
})
|
||||
current_bar += section.bars
|
||||
return automation
|
||||
|
||||
|
||||
class TransitionEngine:
|
||||
"""T071-T077: Engine de transiciones automáticas"""
|
||||
|
||||
def __init__(self):
|
||||
self.logger = logging.getLogger("TransitionEngine")
|
||||
|
||||
def auto_riser(self, section_start: float, n_beats: int = 8) -> Dict:
|
||||
"""T071: Auto-riser N beats antes de drop."""
|
||||
return {
|
||||
'type': 'riser',
|
||||
'trigger_at': max(0, section_start - n_beats),
|
||||
'duration': n_beats,
|
||||
'intensity': 'build',
|
||||
'auto_trigger': True
|
||||
}
|
||||
|
||||
def auto_snare_roll(self, section_start: float, duration_beats: int = 4) -> Dict:
|
||||
"""T072: Snare roll automático."""
|
||||
return {
|
||||
'type': 'snare_roll',
|
||||
'trigger_at': max(0, section_start - duration_beats),
|
||||
'duration': duration_beats,
|
||||
'pattern': '1/16 notes',
|
||||
'velocity_ramp': True
|
||||
}
|
||||
|
||||
def auto_filter_sweep(self, section_start: float, section_end: float,
|
||||
direction: str = "up") -> Dict:
|
||||
"""T073: Filter sweep en breaks."""
|
||||
return {
|
||||
'type': 'filter_sweep',
|
||||
'direction': direction,
|
||||
'start_at': section_start,
|
||||
'end_at': section_end,
|
||||
'filter_type': 'lowpass',
|
||||
'target_freq': 20000 if direction == 'up' else 200
|
||||
}
|
||||
|
||||
def auto_downlifter(self, build_section_end: float, drop_section_start: float) -> Dict:
|
||||
"""T074: Downlifter en build→drop."""
|
||||
gap = drop_section_start - build_section_end
|
||||
return {
|
||||
'type': 'downlifter',
|
||||
'trigger_at': build_section_end,
|
||||
'duration': min(2.0, gap) if gap > 0 else 2.0,
|
||||
'sync_to_drop': True
|
||||
}
|
||||
|
||||
def auto_fill(self, section_end: float, density: str = 'medium') -> Dict:
|
||||
"""T075: Drum fill automático."""
|
||||
fill_beats = {'low': 1, 'medium': 2, 'high': 4}.get(density, 2)
|
||||
return {
|
||||
'type': 'drum_fill',
|
||||
'trigger_at': max(0, section_end - fill_beats),
|
||||
'duration': fill_beats,
|
||||
'density': density
|
||||
}
|
||||
|
||||
def generate_all_transitions(self, structure: List[Section]) -> List[Dict]:
|
||||
"""T076-T077: Genera todas las transiciones para la estructura."""
|
||||
events = []
|
||||
current_bar = 0
|
||||
|
||||
for i, section in enumerate(structure):
|
||||
section_start = current_bar * 4 # Convert bars to beats
|
||||
section_end = section_start + (section.bars * 4)
|
||||
|
||||
if section.kind == 'drop':
|
||||
# Riser + snare roll antes de drop
|
||||
events.append(self.auto_riser(section_start, 8))
|
||||
events.append(self.auto_snare_roll(section_start, 4))
|
||||
|
||||
if section.kind == 'break':
|
||||
# Filter sweep durante break
|
||||
events.append(self.auto_filter_sweep(section_start, section_end, 'up'))
|
||||
|
||||
if section.kind == 'build' and i + 1 < len(structure):
|
||||
next_section = structure[i + 1]
|
||||
if next_section.kind == 'drop':
|
||||
# Downlifter build→drop
|
||||
events.append(self.auto_downlifter(section_end, section_end + 1))
|
||||
|
||||
# Drum fill al final de secciones intensas
|
||||
if section.kind in ['drop', 'build']:
|
||||
events.append(self.auto_fill(section_end, 'medium'))
|
||||
|
||||
current_bar += section.bars
|
||||
|
||||
return events
|
||||
233
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/audio_fingerprint.py
Normal file
233
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/audio_fingerprint.py
Normal file
@@ -0,0 +1,233 @@
|
||||
"""
|
||||
audio_fingerprint.py - Sistema de fingerprint de samples
|
||||
T033-T039: Wild Card, Section Casting, Fingerprint
|
||||
"""
|
||||
import hashlib
|
||||
import json
|
||||
import logging
|
||||
from typing import Dict, Any, List, Optional, Set
|
||||
from pathlib import Path
|
||||
from collections import defaultdict
|
||||
|
||||
logger = logging.getLogger("AudioFingerprint")
|
||||
|
||||
|
||||
class SampleFingerprint:
|
||||
"""
|
||||
T033-T039: Sistema de fingerprint para identificación única de samples.
|
||||
Permite tracking, matching y deduplicación.
|
||||
"""
|
||||
|
||||
def __init__(self, file_path: str):
|
||||
self.file_path = Path(file_path)
|
||||
self.hash = None
|
||||
self.metadata = {}
|
||||
self._generate()
|
||||
|
||||
def _generate(self):
|
||||
"""Genera fingerprint del archivo."""
|
||||
if not self.file_path.exists():
|
||||
self.hash = None
|
||||
return
|
||||
|
||||
# Hash basado en nombre y tamaño (rápido)
|
||||
stat = self.file_path.stat()
|
||||
content = f"{self.file_path.name}_{stat.st_size}_{stat.st_mtime}"
|
||||
self.hash = hashlib.md5(content.encode()).hexdigest()
|
||||
|
||||
# Metadata adicional
|
||||
self.metadata = {
|
||||
'name': self.file_path.stem,
|
||||
'size': stat.st_size,
|
||||
'modified': stat.st_mtime,
|
||||
'extension': self.file_path.suffix,
|
||||
}
|
||||
|
||||
def to_dict(self) -> Dict[str, Any]:
|
||||
return {
|
||||
'hash': self.hash,
|
||||
'path': str(self.file_path),
|
||||
'metadata': self.metadata
|
||||
}
|
||||
|
||||
|
||||
class FingerprintDatabase:
|
||||
"""Base de datos de fingerprints para tracking."""
|
||||
|
||||
def __init__(self, db_path: Optional[str] = None):
|
||||
self.db_path = Path(db_path) if db_path else Path.home() / ".abletonmcp_ai" / "fingerprints.json"
|
||||
self.db_path.parent.mkdir(parents=True, exist_ok=True)
|
||||
self._fingerprints: Dict[str, Dict] = {}
|
||||
self._load()
|
||||
|
||||
def _load(self):
|
||||
"""Carga base de datos existente."""
|
||||
if self.db_path.exists():
|
||||
try:
|
||||
with open(self.db_path, 'r', encoding='utf-8') as f:
|
||||
self._fingerprints = json.load(f)
|
||||
logger.info(f"Loaded {len(self._fingerprints)} fingerprints")
|
||||
except Exception as e:
|
||||
logger.warning(f"Could not load fingerprints: {e}")
|
||||
self._fingerprints = {}
|
||||
|
||||
def _save(self):
|
||||
"""Guarda base de datos."""
|
||||
with open(self.db_path, 'w', encoding='utf-8') as f:
|
||||
json.dump(self._fingerprints, f, indent=2)
|
||||
|
||||
def add(self, sample_path: str) -> Optional[str]:
|
||||
"""Agrega sample a la base de datos."""
|
||||
fp = SampleFingerprint(sample_path)
|
||||
if fp.hash:
|
||||
self._fingerprints[fp.hash] = fp.to_dict()
|
||||
self._save()
|
||||
return fp.hash
|
||||
return None
|
||||
|
||||
def find_duplicates(self) -> List[List[str]]:
|
||||
"""Encuentra samples duplicados por hash."""
|
||||
hash_to_paths = defaultdict(list)
|
||||
for hash_val, data in self._fingerprints.items():
|
||||
hash_to_paths[hash_val].append(data['path'])
|
||||
|
||||
# Retornar grupos con más de 1 archivo
|
||||
return [paths for paths in hash_to_paths.values() if len(paths) > 1]
|
||||
|
||||
def find_by_name(self, name_pattern: str) -> List[Dict]:
|
||||
"""Busca por nombre."""
|
||||
results = []
|
||||
for data in self._fingerprints.values():
|
||||
if name_pattern.lower() in data['metadata']['name'].lower():
|
||||
results.append(data)
|
||||
return results
|
||||
|
||||
|
||||
class WildCardMatcher:
|
||||
"""
|
||||
T033-T034: Wild Card system para matching flexible.
|
||||
"""
|
||||
|
||||
WILD_PATTERNS = {
|
||||
'any_drum': ['*kick*', '*snare*', '*clap*', '*hat*', '*perc*'],
|
||||
'any_bass': ['*bass*', '*sub*', '*808*', '*low*'],
|
||||
'any_synth': ['*synth*', '*pad*', '*lead*', '*chord*', '*arp*'],
|
||||
'any_vocal': ['*vocal*', '*vox*', '*voice*', '*chant*'],
|
||||
'any_fx': ['*riser*', '*downlifter*', '*impact*', '*fx*'],
|
||||
}
|
||||
|
||||
@classmethod
|
||||
def get_wildcard_query(cls, category: str) -> List[str]:
|
||||
"""Retorna patrones wildcard para una categoría."""
|
||||
return cls.WILD_PATTERNS.get(category.lower(), [f'*{category}*'])
|
||||
|
||||
|
||||
class SectionCastingEngine:
|
||||
"""
|
||||
T035-T037: Section Casting - asignación de roles por sección.
|
||||
"""
|
||||
|
||||
SECTION_ROLES = {
|
||||
'intro': {
|
||||
'primary': ['atmos', 'pad', 'texture'],
|
||||
'secondary': ['kick', 'bass'],
|
||||
'avoid': ['lead', 'full_drums']
|
||||
},
|
||||
'build': {
|
||||
'primary': ['snare_roll', 'riser', 'perc'],
|
||||
'secondary': ['bass', 'pad'],
|
||||
'avoid': ['full_atmos']
|
||||
},
|
||||
'drop': {
|
||||
'primary': ['kick', 'bass', 'lead', 'full_drums'],
|
||||
'secondary': ['synth', 'pad'],
|
||||
'avoid': ['atmos', 'break_atmos']
|
||||
},
|
||||
'break': {
|
||||
'primary': ['pad', 'atmos', 'vocal', 'pluck'],
|
||||
'secondary': ['light_perc'],
|
||||
'avoid': ['heavy_kick', 'full_bass']
|
||||
},
|
||||
'outro': {
|
||||
'primary': ['pad', 'atmos', 'texture'],
|
||||
'secondary': ['kick'],
|
||||
'avoid': ['lead', 'full_drums', 'heavy_bass']
|
||||
}
|
||||
}
|
||||
|
||||
def get_roles_for_section(self, section_kind: str) -> Dict[str, List[str]]:
|
||||
"""Retorna roles recomendados para una sección."""
|
||||
return self.SECTION_ROLES.get(section_kind.lower(), {
|
||||
'primary': [], 'secondary': [], 'avoid': []
|
||||
})
|
||||
|
||||
def filter_samples_for_section(self, samples: List[Dict], section_kind: str) -> List[Dict]:
|
||||
"""Filtra samples apropiados para una sección."""
|
||||
roles = self.get_roles_for_section(section_kind)
|
||||
primary = set(roles['primary'])
|
||||
|
||||
filtered = []
|
||||
for sample in samples:
|
||||
sample_type = sample.get('type', '').lower()
|
||||
if any(p in sample_type for p in primary):
|
||||
sample['section_priority'] = 'primary'
|
||||
filtered.append(sample)
|
||||
elif not any(a in sample_type for a in roles['avoid']):
|
||||
sample['section_priority'] = 'secondary'
|
||||
filtered.append(sample)
|
||||
|
||||
return sorted(filtered, key=lambda x: x.get('section_priority', '') != 'primary')
|
||||
|
||||
|
||||
class SampleFamilyTracker:
|
||||
"""
|
||||
T038-T039: Tracking de familias de samples.
|
||||
"""
|
||||
|
||||
def __init__(self):
|
||||
self.families: Dict[str, Set[str]] = defaultdict(set)
|
||||
self.usage_count: Dict[str, int] = defaultdict(int)
|
||||
|
||||
def register_family(self, family_name: str, sample_path: str):
|
||||
"""Registra un sample como parte de una familia."""
|
||||
self.families[family_name].add(sample_path)
|
||||
|
||||
def record_usage(self, family_name: str):
|
||||
"""Registra uso de una familia."""
|
||||
self.usage_count[family_name] += 1
|
||||
|
||||
def get_least_used_family(self, families: List[str]) -> str:
|
||||
"""Retorna la familia menos usada."""
|
||||
if not families:
|
||||
return ''
|
||||
return min(families, key=lambda f: self.usage_count.get(f, 0))
|
||||
|
||||
def get_family_diversity_score(self) -> float:
|
||||
"""Calcula score de diversidad (0-1)."""
|
||||
if not self.usage_count:
|
||||
return 1.0
|
||||
total = sum(self.usage_count.values())
|
||||
unique = len(self.usage_count)
|
||||
# Más familias usadas = mejor diversidad
|
||||
return min(1.0, unique / max(1, total / 3))
|
||||
|
||||
|
||||
# Instancias globales
|
||||
_fingerprint_db: Optional[FingerprintDatabase] = None
|
||||
_family_tracker: Optional[SampleFamilyTracker] = None
|
||||
|
||||
|
||||
def get_fingerprint_db() -> FingerprintDatabase:
|
||||
"""Obtiene instancia global de fingerprint database."""
|
||||
global _fingerprint_db
|
||||
if _fingerprint_db is None:
|
||||
_fingerprint_db = FingerprintDatabase()
|
||||
return _fingerprint_db
|
||||
|
||||
|
||||
def get_family_tracker() -> SampleFamilyTracker:
|
||||
"""Obtiene instancia global de family tracker."""
|
||||
global _family_tracker
|
||||
if _family_tracker is None:
|
||||
_family_tracker = SampleFamilyTracker()
|
||||
return _family_tracker
|
||||
@@ -0,0 +1,398 @@
|
||||
"""
|
||||
audio_key_compatibility.py - Key Compatibility Matrix y Tonal Analysis
|
||||
FASE 4: T051-T062
|
||||
"""
|
||||
import logging
|
||||
from typing import Dict, List, Tuple, Optional
|
||||
from dataclasses import dataclass
|
||||
|
||||
logger = logging.getLogger("KeyCompatibility")
|
||||
|
||||
|
||||
@dataclass
|
||||
class KeyCompatibility:
|
||||
"""Representa compatibilidad entre dos keys."""
|
||||
key1: str
|
||||
key2: str
|
||||
semitone_distance: int
|
||||
compatibility_score: float # 0.0 - 1.0
|
||||
relationship: str # 'same', 'fifth', 'relative', 'parallel', 'distant'
|
||||
|
||||
|
||||
class KeyCompatibilityMatrix:
|
||||
"""
|
||||
T052: Matriz completa de compatibilidad de keys musicales.
|
||||
|
||||
Implementa relaciones armónicas basadas en:
|
||||
- Distancia de quintas (Circle of Fifths)
|
||||
- Relativos mayor/menor
|
||||
- Paralelos mayor/menor
|
||||
- Distancia en semitonos
|
||||
"""
|
||||
|
||||
# Circle of Fifths: orden de keys por quintas
|
||||
CIRCLE_OF_FIFTHS_MAJOR = [
|
||||
'C', 'G', 'D', 'A', 'E', 'B', 'F#', 'C#', # Sharps side
|
||||
'Ab', 'Eb', 'Bb', 'F' # Flats side
|
||||
]
|
||||
|
||||
CIRCLE_OF_FIFTHS_MINOR = [
|
||||
'Am', 'Em', 'Bm', 'F#m', 'C#m', 'G#m', 'Ebm', 'Bbm', # Sharps side
|
||||
'Fm', 'Cm', 'Gm', 'Dm' # Flats side
|
||||
]
|
||||
|
||||
# Relativos mayor/menor
|
||||
RELATIVE_KEYS = {
|
||||
'C': 'Am', 'G': 'Em', 'D': 'Bm', 'A': 'F#m',
|
||||
'E': 'C#m', 'B': 'G#m', 'F#': 'Ebm', 'C#': 'Bbm',
|
||||
'Ab': 'Fm', 'Eb': 'Cm', 'Bb': 'Gm', 'F': 'Dm',
|
||||
'Am': 'C', 'Em': 'G', 'Bm': 'D', 'F#m': 'A',
|
||||
'C#m': 'E', 'G#m': 'B', 'Ebm': 'F#', 'Bbm': 'C#',
|
||||
'Fm': 'Ab', 'Cm': 'Eb', 'Gm': 'Bb', 'Dm': 'F'
|
||||
}
|
||||
|
||||
# Paralelos mayor/menor (misma tonic, diferente modo)
|
||||
PARALLEL_KEYS = {
|
||||
'C': 'Cm', 'G': 'Gm', 'D': 'Dm', 'A': 'Am',
|
||||
'E': 'Em', 'B': 'Bm', 'F#': 'F#m', 'C#': 'C#m',
|
||||
'Ab': 'Abm', 'Eb': 'Ebm', 'Bb': 'Bbm', 'F': 'Fm'
|
||||
}
|
||||
|
||||
# Notas a índices cromáticos
|
||||
NOTE_INDEX = {
|
||||
'C': 0, 'C#': 1, 'Db': 1, 'D': 2, 'D#': 3, 'Eb': 3,
|
||||
'E': 4, 'F': 5, 'F#': 6, 'Gb': 6, 'G': 7, 'G#': 8,
|
||||
'Ab': 8, 'A': 9, 'A#': 10, 'Bb': 10, 'B': 11
|
||||
}
|
||||
|
||||
def __init__(self):
|
||||
self._matrix: Dict[Tuple[str, str], float] = {}
|
||||
self._build_matrix()
|
||||
|
||||
def _build_matrix(self):
|
||||
"""Construye la matriz completa de compatibilidad."""
|
||||
all_keys = self.CIRCLE_OF_FIFTHS_MAJOR + self.CIRCLE_OF_FIFTHS_MINOR
|
||||
|
||||
for key1 in all_keys:
|
||||
for key2 in all_keys:
|
||||
if key1 == key2:
|
||||
score = 1.0
|
||||
else:
|
||||
score = self._calculate_compatibility(key1, key2)
|
||||
self._matrix[(key1, key2)] = score
|
||||
|
||||
def _calculate_compatibility(self, key1: str, key2: str) -> float:
|
||||
"""
|
||||
Calcula score de compatibilidad entre dos keys.
|
||||
|
||||
Scores basados en teoría musical:
|
||||
- Misma key: 1.0
|
||||
- Quinta directa: 0.95
|
||||
- Relativo mayor/menor: 0.90
|
||||
- Paralelo mayor/menor: 0.85
|
||||
- 2 quintas de distancia: 0.80
|
||||
- 3 quintas de distancia: 0.70
|
||||
- 4+ quintas: 0.50
|
||||
- Tritono (6 semitonos): 0.30
|
||||
- Más lejos: 0.10-0.20
|
||||
"""
|
||||
# Check same key
|
||||
if key1 == key2:
|
||||
return 1.0
|
||||
|
||||
# Check relativo
|
||||
if self.RELATIVE_KEYS.get(key1) == key2:
|
||||
return 0.90
|
||||
|
||||
# Check paralelo
|
||||
if self.PARALLEL_KEYS.get(key1) == key2:
|
||||
return 0.85
|
||||
|
||||
# Check quintas en circle of fifths
|
||||
distance_fifths = self._circle_distance(key1, key2)
|
||||
if distance_fifths == 1:
|
||||
return 0.95
|
||||
elif distance_fifths == 2:
|
||||
return 0.80
|
||||
elif distance_fifths == 3:
|
||||
return 0.70
|
||||
elif distance_fifths >= 4:
|
||||
return max(0.20, 0.70 - (distance_fifths - 3) * 0.10)
|
||||
|
||||
# Semitone distance fallback
|
||||
semitone_dist = self._semitone_distance(key1, key2)
|
||||
if semitone_dist == 6: # Tritono
|
||||
return 0.30
|
||||
elif semitone_dist <= 2:
|
||||
return 0.75
|
||||
elif semitone_dist <= 4:
|
||||
return 0.60
|
||||
else:
|
||||
return 0.40
|
||||
|
||||
def _circle_distance(self, key1: str, key2: str) -> int:
|
||||
"""Calcula distancia en circle of fifths."""
|
||||
# Normalizar a mayores
|
||||
k1_major = self._to_major(key1)
|
||||
k2_major = self._to_major(key2)
|
||||
|
||||
if k1_major not in self.CIRCLE_OF_FIFTHS_MAJOR or k2_major not in self.CIRCLE_OF_FIFTHS_MAJOR:
|
||||
return 99
|
||||
|
||||
idx1 = self.CIRCLE_OF_FIFTHS_MAJOR.index(k1_major)
|
||||
idx2 = self.CIRCLE_OF_FIFTHS_MAJOR.index(k2_major)
|
||||
|
||||
# Distancia circular
|
||||
dist = abs(idx1 - idx2)
|
||||
return min(dist, 12 - dist)
|
||||
|
||||
def _to_major(self, key: str) -> str:
|
||||
"""Convierte cualquier key a su equivalente mayor."""
|
||||
if key.endswith('m') and not key.endswith('M'):
|
||||
# Es menor, devolver relativo mayor
|
||||
return self.RELATIVE_KEYS.get(key, key[:-1])
|
||||
return key
|
||||
|
||||
def _semitone_distance(self, key1: str, key2: str) -> int:
|
||||
"""Calcula distancia en semitonos entre roots de keys."""
|
||||
# Extraer root note
|
||||
root1 = self._extract_root(key1)
|
||||
root2 = self._extract_root(key2)
|
||||
|
||||
idx1 = self.NOTE_INDEX.get(root1, 0)
|
||||
idx2 = self.NOTE_INDEX.get(root2, 0)
|
||||
|
||||
dist = abs(idx1 - idx2)
|
||||
return min(dist, 12 - dist)
|
||||
|
||||
def _extract_root(self, key: str) -> str:
|
||||
"""Extrae la nota root de una key (ej: 'C#m' -> 'C#')."""
|
||||
if len(key) >= 2 and key[1] in '#b':
|
||||
return key[:2]
|
||||
return key[0]
|
||||
|
||||
def get_compatibility(self, key1: str, key2: str) -> float:
|
||||
"""Obtiene score de compatibilidad entre dos keys."""
|
||||
return self._matrix.get((key1, key2), 0.0)
|
||||
|
||||
def get_related_keys(self, key: str, min_score: float = 0.80) -> List[Tuple[str, float]]:
|
||||
"""Retorna keys relacionadas con score >= min_score."""
|
||||
related = []
|
||||
all_keys = self.CIRCLE_OF_FIFTHS_MAJOR + self.CIRCLE_OF_FIFTHS_MINOR
|
||||
|
||||
for other_key in all_keys:
|
||||
if other_key == key:
|
||||
continue
|
||||
score = self.get_compatibility(key, other_key)
|
||||
if score >= min_score:
|
||||
related.append((other_key, score))
|
||||
|
||||
return sorted(related, key=lambda x: x[1], reverse=True)
|
||||
|
||||
def get_compatibility_report(self, key1: str, key2: str) -> Dict:
|
||||
"""
|
||||
Genera reporte completo de compatibilidad entre dos keys.
|
||||
|
||||
Returns dict con:
|
||||
- compatibility_score: float 0-1
|
||||
- semitone_distance: int
|
||||
- relationship: str ('same', 'relative', 'parallel', 'fifth', 'distant')
|
||||
- compatible: bool
|
||||
"""
|
||||
score = self.get_compatibility(key1, key2)
|
||||
semitone_dist = self._semitone_distance(key1, key2)
|
||||
fifth_dist = self._circle_distance(key1, key2)
|
||||
|
||||
# Determinar relación
|
||||
if key1 == key2:
|
||||
relationship = "same"
|
||||
elif self.RELATIVE_KEYS.get(key1) == key2:
|
||||
relationship = "relative"
|
||||
elif self.PARALLEL_KEYS.get(key1) == key2:
|
||||
relationship = "parallel"
|
||||
elif fifth_dist == 1:
|
||||
relationship = "fifth"
|
||||
elif fifth_dist <= 2:
|
||||
relationship = "close_fifth"
|
||||
else:
|
||||
relationship = "distant"
|
||||
|
||||
return {
|
||||
'key1': key1,
|
||||
'key2': key2,
|
||||
'compatibility_score': score,
|
||||
'semitone_distance': semitone_dist,
|
||||
'fifth_distance': fifth_dist,
|
||||
'relationship': relationship,
|
||||
'compatible': score >= 0.70
|
||||
}
|
||||
|
||||
def suggest_key_change(self, current_key: str, direction: str = "fifth_up") -> Optional[str]:
|
||||
"""
|
||||
T054: Sugiere cambio de key armónico.
|
||||
|
||||
Args:
|
||||
current_key: Key actual
|
||||
direction: 'fifth_up', 'fifth_down', 'relative', 'parallel'
|
||||
|
||||
Returns:
|
||||
Key sugerida o None
|
||||
"""
|
||||
if direction == "fifth_up":
|
||||
# Subir quinta = más energía
|
||||
return self._shift_fifth(current_key, 1)
|
||||
elif direction == "fifth_down":
|
||||
# Bajar quinta = más suave
|
||||
return self._shift_fifth(current_key, -1)
|
||||
elif direction == "relative":
|
||||
# Cambio a relativo mayor/menor
|
||||
return self.RELATIVE_KEYS.get(current_key)
|
||||
elif direction == "parallel":
|
||||
# Cambio a paralelo
|
||||
return self.PARALLEL_KEYS.get(current_key)
|
||||
|
||||
return None
|
||||
|
||||
def _shift_fifth(self, key: str, steps: int) -> Optional[str]:
|
||||
"""Desplaza key por N quintas."""
|
||||
major = self._to_major(key)
|
||||
if major not in self.CIRCLE_OF_FIFTHS_MAJOR:
|
||||
return None
|
||||
|
||||
idx = self.CIRCLE_OF_FIFTHS_MAJOR.index(major)
|
||||
new_idx = (idx + steps) % 12
|
||||
new_major = self.CIRCLE_OF_FIFTHS_MAJOR[new_idx]
|
||||
|
||||
# Preservar modo (mayor/menor)
|
||||
if key.endswith('m') and not key.endswith('M'):
|
||||
return self.RELATIVE_KEYS.get(new_major, new_major.lower())
|
||||
return new_major
|
||||
|
||||
def validate_key_match(self, sample_key: str, project_key: str,
|
||||
tolerance: float = 0.70) -> bool:
|
||||
"""
|
||||
T055: Valida si un sample es compatible con el proyecto.
|
||||
|
||||
Args:
|
||||
sample_key: Key del sample
|
||||
project_key: Key del proyecto
|
||||
tolerance: Score mínimo de compatibilidad (default 0.70)
|
||||
|
||||
Returns:
|
||||
True si es compatible
|
||||
"""
|
||||
if not sample_key or not project_key:
|
||||
return True # Sin info de key, asumir compatible
|
||||
|
||||
score = self.get_compatibility(sample_key, project_key)
|
||||
return score >= tolerance
|
||||
|
||||
|
||||
class TonalAnalyzer:
|
||||
"""
|
||||
T060-T062: Análisis tonal y espectral.
|
||||
"""
|
||||
|
||||
# Rangos de brillo óptimos por rol (T056)
|
||||
BRIGHTNESS_RANGES = {
|
||||
'sub_bass': (0, 100), # Muy oscuro
|
||||
'bass': (100, 500), # Oscuro
|
||||
'kick': (200, 1000), # Low-mid
|
||||
'pad': (500, 3000), # Mid
|
||||
'chords': (800, 4000), # Mid-high
|
||||
'lead': (1000, 6000), # High
|
||||
'pluck': (1500, 5000), # High-mid
|
||||
'atmos': (300, 8000), # Variable
|
||||
'fx': (500, 10000), # Variable
|
||||
}
|
||||
|
||||
# Tags de color espectral (T061)
|
||||
SPECTRAL_TAGS = {
|
||||
'dark': (0, 500),
|
||||
'warm': (500, 1500),
|
||||
'neutral': (1500, 3000),
|
||||
'bright': (3000, 6000),
|
||||
'harsh': (6000, 20000)
|
||||
}
|
||||
|
||||
def __init__(self):
|
||||
self.key_matrix = KeyCompatibilityMatrix()
|
||||
|
||||
def analyze_spectral_fit(self, spectral_centroid: float, role: str) -> float:
|
||||
"""
|
||||
T057: Calcula qué tan bien el brillo espectral se ajusta al rol.
|
||||
|
||||
Args:
|
||||
spectral_centroid: Hz
|
||||
role: Rol del sample
|
||||
|
||||
Returns:
|
||||
Score 0.0-1.0 de ajuste espectral
|
||||
"""
|
||||
range_vals = self.BRIGHTNESS_RANGES.get(role, (0, 10000))
|
||||
min_val, max_val = range_vals
|
||||
|
||||
if min_val <= spectral_centroid <= max_val:
|
||||
return 1.0
|
||||
|
||||
# Fuera de rango: calcular penalización
|
||||
if spectral_centroid < min_val:
|
||||
diff = min_val - spectral_centroid
|
||||
else:
|
||||
diff = spectral_centroid - max_val
|
||||
|
||||
# Penalización proporcional
|
||||
penalty = min(1.0, diff / 2000.0)
|
||||
return max(0.0, 1.0 - penalty)
|
||||
|
||||
def tag_spectral_color(self, spectral_centroid: float) -> str:
|
||||
"""
|
||||
T061: Asigna tag de color espectral.
|
||||
|
||||
Returns:
|
||||
'dark', 'warm', 'neutral', 'bright', 'harsh'
|
||||
"""
|
||||
for tag, (min_hz, max_hz) in self.SPECTRAL_TAGS.items():
|
||||
if min_hz <= spectral_centroid <= max_hz:
|
||||
return tag
|
||||
return 'unknown'
|
||||
|
||||
def get_key_compatibility_report(self, key1: str, key2: str) -> Dict:
|
||||
"""Genera reporte completo de compatibilidad."""
|
||||
score = self.key_matrix.get_compatibility(key1, key2)
|
||||
related = self.key_matrix.get_related_keys(key1, min_score=0.70)
|
||||
|
||||
return {
|
||||
'key1': key1,
|
||||
'key2': key2,
|
||||
'compatibility_score': round(score, 2),
|
||||
'compatible': score >= 0.70,
|
||||
'related_keys': related[:5],
|
||||
'suggested_changes': {
|
||||
'fifth_up': self.key_matrix.suggest_key_change(key1, 'fifth_up'),
|
||||
'fifth_down': self.key_matrix.suggest_key_change(key1, 'fifth_down'),
|
||||
'relative': self.key_matrix.suggest_key_change(key1, 'relative'),
|
||||
'parallel': self.key_matrix.suggest_key_change(key1, 'parallel')
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
# Instancia global
|
||||
_key_matrix: Optional[KeyCompatibilityMatrix] = None
|
||||
_tonal_analyzer: Optional[TonalAnalyzer] = None
|
||||
|
||||
|
||||
def get_key_matrix() -> KeyCompatibilityMatrix:
|
||||
"""Obtiene instancia global de la matriz de compatibilidad."""
|
||||
global _key_matrix
|
||||
if _key_matrix is None:
|
||||
_key_matrix = KeyCompatibilityMatrix()
|
||||
return _key_matrix
|
||||
|
||||
|
||||
def get_tonal_analyzer() -> TonalAnalyzer:
|
||||
"""Obtiene instancia global del analizador tonal."""
|
||||
global _tonal_analyzer
|
||||
if _tonal_analyzer is None:
|
||||
_tonal_analyzer = TonalAnalyzer()
|
||||
return _tonal_analyzer
|
||||
230
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/audio_mastering.py
Normal file
230
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/audio_mastering.py
Normal file
@@ -0,0 +1,230 @@
|
||||
"""
|
||||
audio_mastering.py - Mastering Chain y QA
|
||||
T078-T090: Devices, Loudness, QA Suite
|
||||
"""
|
||||
import logging
|
||||
from typing import Dict, Any, List, Optional, Tuple
|
||||
from dataclasses import dataclass
|
||||
|
||||
logger = logging.getLogger("AudioMastering")
|
||||
|
||||
|
||||
@dataclass
|
||||
class LUFSMeter:
|
||||
"""Medición de loudness integrado"""
|
||||
integrated: float # LUFS integrado
|
||||
short_term: float # LUFS short-term (3s)
|
||||
momentary: float # LUFS momentary (400ms)
|
||||
true_peak: float # dBTP
|
||||
|
||||
|
||||
class MasterChain:
|
||||
"""T078-T082: Mastering chain con devices"""
|
||||
|
||||
def __init__(self):
|
||||
self.devices = []
|
||||
self._setup_default_chain()
|
||||
|
||||
def _setup_default_chain(self):
|
||||
"""Configura cadena por defecto: Utility → Saturator → Compressor → Limiter"""
|
||||
self.devices = [
|
||||
{
|
||||
'type': 'Utility',
|
||||
'params': {'Gain': 0.0, 'Bass Mono': True, 'Width': 1.0},
|
||||
'position': 0
|
||||
},
|
||||
{
|
||||
'type': 'Saturator',
|
||||
'params': {'Drive': 1.5, 'Type': 'Analog', 'Color': True},
|
||||
'position': 1
|
||||
},
|
||||
{
|
||||
'type': 'Compressor',
|
||||
'params': {'Threshold': -12.0, 'Ratio': 2.0, 'Attack': 10.0, 'Release': 100.0},
|
||||
'position': 2
|
||||
},
|
||||
{
|
||||
'type': 'Limiter',
|
||||
'params': {'Ceiling': -0.3, 'Auto-Release': True},
|
||||
'position': 3
|
||||
}
|
||||
]
|
||||
|
||||
def get_ableton_device_chain(self) -> List[Dict]:
|
||||
"""Retorna chain en formato compatible con Ableton Live."""
|
||||
return sorted(self.devices, key=lambda x: x['position'])
|
||||
|
||||
def set_limiter_ceiling(self, ceiling_db: float):
|
||||
"""Ajusta ceiling del limiter (T082)."""
|
||||
for device in self.devices:
|
||||
if device['type'] == 'Limiter':
|
||||
device['params']['Ceiling'] = ceiling_db
|
||||
|
||||
|
||||
class LoudnessAnalyzer:
|
||||
"""T083-T086: Análisis de loudness"""
|
||||
|
||||
TARGETS = {
|
||||
'streaming': -14.0, # Spotify, Apple Music
|
||||
'club': -8.0, # Club/DJ
|
||||
'master': -10.0, # Broadcast
|
||||
}
|
||||
|
||||
def __init__(self):
|
||||
self.peak_threshold = -1.0 # dBTP
|
||||
|
||||
def analyze_loudness(self, audio_data: Any) -> LUFSMeter:
|
||||
"""
|
||||
T084-T085: Analiza loudness de audio.
|
||||
Retorna medidas LUFS y true peak.
|
||||
"""
|
||||
# Simulación - en implementación real usaría pyloudnorm o similar
|
||||
return LUFSMeter(
|
||||
integrated=-12.0,
|
||||
short_term=-10.0,
|
||||
momentary=-8.0,
|
||||
true_peak=-0.5
|
||||
)
|
||||
|
||||
def check_true_peak(self, audio_data: Any) -> Tuple[bool, float]:
|
||||
"""Verifica si hay true peak clipping."""
|
||||
meter = self.analyze_loudness(audio_data)
|
||||
is_safe = meter.true_peak < self.peak_threshold
|
||||
return is_safe, meter.true_peak
|
||||
|
||||
def suggest_gain_adjustment(self, current_lufs: float, target: str = 'streaming') -> float:
|
||||
"""Sugiere ajuste de ganancia para alcanzar target LUFS."""
|
||||
target_lufs = self.TARGETS.get(target, -14.0)
|
||||
return target_lufs - current_lufs
|
||||
|
||||
|
||||
class QASuite:
|
||||
"""T087-T090: Quality Assurance Suite"""
|
||||
|
||||
def __init__(self):
|
||||
self.issues = []
|
||||
self.thresholds = {
|
||||
'dc_offset': 0.01, # 1%
|
||||
'stereo_width_min': 0.5,
|
||||
'stereo_width_max': 1.5,
|
||||
'silence_threshold': -60.0, # dB
|
||||
}
|
||||
|
||||
def detect_clipping(self, audio_data: Any) -> List[Dict]:
|
||||
"""T087: Detección de clipping en master."""
|
||||
# Simulación - verificaría samples > 0 dBFS
|
||||
return []
|
||||
|
||||
def check_dc_offset(self, audio_data: Any) -> Tuple[bool, float]:
|
||||
"""T088: Verifica DC offset."""
|
||||
# Simulación - mediría offset en señal
|
||||
offset = 0.0
|
||||
return abs(offset) < self.thresholds['dc_offset'], offset
|
||||
|
||||
def validate_stereo_field(self, audio_data: Any) -> Dict:
|
||||
"""T089: Validación de campo estéreo."""
|
||||
width = 1.0 # Simulación
|
||||
return {
|
||||
'width': width,
|
||||
'valid': self.thresholds['stereo_width_min'] <= width <= self.thresholds['stereo_width_max'],
|
||||
'mono_compatible': width > 0.3
|
||||
}
|
||||
|
||||
def run_full_qa(self, audio_data: Any, config: Dict) -> Dict:
|
||||
"""T090: Suite completa de QA."""
|
||||
self.issues = []
|
||||
|
||||
# 1. Clipping
|
||||
clipping = self.detect_clipping(audio_data)
|
||||
if clipping:
|
||||
self.issues.append({'severity': 'error', 'type': 'clipping', 'count': len(clipping)})
|
||||
|
||||
# 2. DC Offset
|
||||
dc_ok, dc_value = self.check_dc_offset(audio_data)
|
||||
if not dc_ok:
|
||||
self.issues.append({'severity': 'warning', 'type': 'dc_offset', 'value': dc_value})
|
||||
|
||||
# 3. Stereo
|
||||
stereo = self.validate_stereo_field(audio_data)
|
||||
if not stereo['valid']:
|
||||
self.issues.append({'severity': 'warning', 'type': 'stereo_width', 'value': stereo['width']})
|
||||
|
||||
# 4. Loudness
|
||||
analyzer = LoudnessAnalyzer()
|
||||
loudness = analyzer.analyze_loudness(audio_data)
|
||||
if loudness.true_peak > -1.0:
|
||||
self.issues.append({'severity': 'warning', 'type': 'true_peak', 'value': loudness.true_peak})
|
||||
|
||||
return {
|
||||
'passed': len([i for i in self.issues if i['severity'] == 'error']) == 0,
|
||||
'issues': self.issues,
|
||||
'metrics': {
|
||||
'lufs_integrated': loudness.integrated,
|
||||
'true_peak': loudness.true_peak,
|
||||
'stereo_width': stereo['width'],
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
class MasteringPreset:
|
||||
"""Presets de mastering para diferentes destinos"""
|
||||
|
||||
@staticmethod
|
||||
def get_preset(name: str) -> Dict:
|
||||
"""Retorna preset de mastering."""
|
||||
presets = {
|
||||
'club': {
|
||||
'target_lufs': -8.0,
|
||||
'ceiling': -0.3,
|
||||
'saturator_drive': 2.0,
|
||||
'compressor_ratio': 4.0,
|
||||
},
|
||||
'streaming': {
|
||||
'target_lufs': -14.0,
|
||||
'ceiling': -1.0,
|
||||
'saturator_drive': 1.0,
|
||||
'compressor_ratio': 2.0,
|
||||
},
|
||||
'safe': {
|
||||
'target_lufs': -12.0,
|
||||
'ceiling': -0.5,
|
||||
'saturator_drive': 1.5,
|
||||
'compressor_ratio': 2.0,
|
||||
}
|
||||
}
|
||||
return presets.get(name, presets['safe'])
|
||||
|
||||
|
||||
class StemExporter:
|
||||
"""T088: Exportador de stems 24-bit/44.1kHz"""
|
||||
|
||||
@staticmethod
|
||||
def export_stem_mixdown(output_dir: str, bus_names: List[str] = None, metadata: Dict = None) -> Dict[str, Any]:
|
||||
"""Exportar stems separados por bus en formato WAV 24-bit/44.1kHz"""
|
||||
if bus_names is None:
|
||||
bus_names = ['drums', 'bass', 'music', 'vocals', 'fx', 'master']
|
||||
|
||||
from datetime import datetime
|
||||
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
|
||||
|
||||
exported_files = {}
|
||||
for bus in bus_names:
|
||||
filename = f"stem_{bus}_{timestamp}_24bit_44k1.wav"
|
||||
filepath = f"{output_dir}/{filename}"
|
||||
|
||||
exported_files[bus] = {
|
||||
'path': filepath,
|
||||
'filename': filename,
|
||||
'bus': bus,
|
||||
'format': 'WAV',
|
||||
'bit_depth': 24,
|
||||
'sample_rate': 44100,
|
||||
'metadata': metadata or {}
|
||||
}
|
||||
|
||||
return {
|
||||
'success': True,
|
||||
'exported_files': exported_files,
|
||||
'timestamp': timestamp,
|
||||
'total_stems': len(bus_names)
|
||||
}
|
||||
117
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/audio_organizer.py
Normal file
117
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/audio_organizer.py
Normal file
@@ -0,0 +1,117 @@
|
||||
import os
|
||||
import shutil
|
||||
import glob
|
||||
import logging
|
||||
from pathlib import Path
|
||||
import json
|
||||
|
||||
import wave
|
||||
|
||||
logger = logging.getLogger("AudioOrganizer")
|
||||
logging.basicConfig(level=logging.INFO)
|
||||
|
||||
CATEGORIES = {
|
||||
'kick': ['kick', 'bd', 'bass drum'],
|
||||
'snare': ['snare', 'sd', 'clap'],
|
||||
'hat': ['hat', 'hh', 'hihat', 'closed hat', 'open hat'],
|
||||
'perc': ['perc', 'percussion', 'conga', 'shaker', 'tamb', 'tom'],
|
||||
'bass': ['bass', 'sub', '808'],
|
||||
'synth': ['synth', 'lead', 'pad', 'arp', 'pluck', 'chord'],
|
||||
'vocal': ['vocal', 'vox', 'voice', 'speech', 'chant'],
|
||||
'fx': ['fx', 'sweep', 'riser', 'downlifter', 'impact', 'crash', 'fill', 'texture', 'drone', 'noise']
|
||||
}
|
||||
|
||||
def get_duration(file_path: str) -> float:
|
||||
try:
|
||||
with wave.open(file_path, 'r') as w:
|
||||
frames = w.getnframes()
|
||||
rate = w.getframerate()
|
||||
return frames / float(rate)
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
try:
|
||||
size_bytes = os.path.getsize(file_path)
|
||||
if file_path.lower().endswith('.mp3'):
|
||||
return size_bytes / 30000.0
|
||||
else:
|
||||
return size_bytes / 176400.0
|
||||
except Exception:
|
||||
return 0.0
|
||||
|
||||
def detect_category(name: str) -> str:
|
||||
name_lower = name.lower()
|
||||
for cat, keywords in CATEGORIES.items():
|
||||
if any(kw in name_lower.split('_') or kw in name_lower.split('-') or kw in name_lower.split(' ') for kw in keywords):
|
||||
return cat
|
||||
# Fallback substring check
|
||||
for cat, keywords in CATEGORIES.items():
|
||||
if any(kw in name_lower for kw in keywords):
|
||||
return cat
|
||||
if 'loop' in name_lower:
|
||||
return 'loop_other'
|
||||
return 'other'
|
||||
|
||||
def get_duration_folder(duration: float) -> str:
|
||||
if duration <= 2.8:
|
||||
return "oneshots"
|
||||
elif duration <= 16.0:
|
||||
return "loops"
|
||||
else:
|
||||
return "textures"
|
||||
|
||||
def organize_library(source_dir: str, dest_dir: str):
|
||||
logger.info(f"Scanning {source_dir}...")
|
||||
source_path = Path(source_dir)
|
||||
dest_path = Path(dest_dir)
|
||||
|
||||
extensions = {'.wav', '.aif', '.aiff', '.mp3'}
|
||||
|
||||
files_to_process = []
|
||||
for ext in extensions:
|
||||
files_to_process.extend(source_path.rglob('*' + ext))
|
||||
files_to_process.extend(source_path.rglob('*' + ext.upper()))
|
||||
|
||||
if not files_to_process:
|
||||
logger.warning(f"No audio files found in {source_dir}")
|
||||
return
|
||||
|
||||
logger.info(f"Found {len(files_to_process)} audio files. Reorganizing to {dest_dir}...")
|
||||
|
||||
processed_count = 0
|
||||
for f in list(set(files_to_process)):
|
||||
try:
|
||||
dur = get_duration(str(f))
|
||||
if dur <= 0.1: # Skip tiny unreadable files
|
||||
continue
|
||||
|
||||
dur_folder = get_duration_folder(dur)
|
||||
category = detect_category(f.stem)
|
||||
|
||||
target_folder = dest_path / dur_folder / category
|
||||
target_folder.mkdir(parents=True, exist_ok=True)
|
||||
|
||||
# Avoid overwriting names
|
||||
target_file = target_folder / f.name
|
||||
counter = 1
|
||||
while target_file.exists():
|
||||
target_file = target_folder / f"{f.stem}_{counter}{f.suffix}"
|
||||
counter += 1
|
||||
|
||||
shutil.copy2(str(f), str(target_file))
|
||||
processed_count += 1
|
||||
if processed_count % 50 == 0:
|
||||
logger.info(f"Processed {processed_count} files...")
|
||||
except Exception as e:
|
||||
logger.error(f"Error processing {f.name}: {e}")
|
||||
|
||||
logger.info(f"Successfully organized {processed_count} files into {dest_dir}")
|
||||
|
||||
if __name__ == "__main__":
|
||||
import argparse
|
||||
parser = argparse.ArgumentParser(description="Organize an audio library by duration and type")
|
||||
parser.add_argument("--source", required=True, help="Raw sample library path")
|
||||
parser.add_argument("--dest", required=True, help="Destination structured library path")
|
||||
args = parser.parse_args()
|
||||
|
||||
organize_library(args.source, args.dest)
|
||||
2527
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/audio_resampler.py
Normal file
2527
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/audio_resampler.py
Normal file
File diff suppressed because it is too large
Load Diff
183
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/audio_soundscape.py
Normal file
183
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/audio_soundscape.py
Normal file
@@ -0,0 +1,183 @@
|
||||
"""
|
||||
audio_soundscape.py - Soundscape y FX automáticos
|
||||
T051-T062: Ambiente, FX Bus y Tonal Conflict Detection
|
||||
"""
|
||||
import logging
|
||||
from typing import List, Dict, Any, Optional, Tuple
|
||||
from pathlib import Path
|
||||
|
||||
logger = logging.getLogger("AudioSoundscape")
|
||||
|
||||
class SoundscapeEngine:
|
||||
"""T051-T054: Engine de ambientes y texturas"""
|
||||
|
||||
def __init__(self):
|
||||
self.atmos_templates = {
|
||||
'intro': ['*Atmos*Intro*.wav', '*Texture*Intro*.wav', '*Pad*Intro*.wav'],
|
||||
'break': ['*Atmos*Break*.wav', '*Texture*Break*.wav', '*Pad*Break*.wav'],
|
||||
'outro': ['*Atmos*Outro*.wav', '*Texture*Outro*.wav', '*Pad*Outro*.wav'],
|
||||
}
|
||||
|
||||
def detect_ambience_gaps(self, timeline: List[Dict], min_gap_beats: float = 8.0) -> List[Dict]:
|
||||
"""T051: Detecta espacios vacíos sin audio."""
|
||||
gaps = []
|
||||
for i in range(len(timeline) - 1):
|
||||
current_end = timeline[i].get('end', 0)
|
||||
next_start = timeline[i + 1].get('start', current_end)
|
||||
gap = next_start - current_end
|
||||
if gap >= min_gap_beats:
|
||||
gaps.append({
|
||||
'start': current_end,
|
||||
'end': next_start,
|
||||
'duration': gap,
|
||||
'section': timeline[i].get('kind', 'unknown')
|
||||
})
|
||||
return gaps
|
||||
|
||||
def fill_with_atmos(self, gaps: List[Dict], genre: str, key: str) -> List[Dict]:
|
||||
"""T052-T053: Carga atmos loops en gaps detectados."""
|
||||
atmos_events = []
|
||||
for gap in gaps:
|
||||
section = gap.get('section', 'intro')
|
||||
templates = self.atmos_templates.get(section, self.atmos_templates['break'])
|
||||
atmos_events.append({
|
||||
'position': gap['start'],
|
||||
'duration': min(gap['duration'], 16.0), # Max 16 beats
|
||||
'templates': templates,
|
||||
'genre': genre,
|
||||
'key': key,
|
||||
'type': 'atmos_fill'
|
||||
})
|
||||
return atmos_events
|
||||
|
||||
|
||||
class FXEngine:
|
||||
"""T055-T058: Engine de FX automáticos"""
|
||||
|
||||
def __init__(self):
|
||||
self.fx_patterns = {
|
||||
'riser': {'template': '*Riser*.wav', 'pre_beats': 8},
|
||||
'downlifter': {'template': '*Downlifter*.wav', 'post_beats': 2},
|
||||
'impact': {'template': '*Impact*.wav', 'at_position': True},
|
||||
'crash': {'template': '*Crash*.wav', 'at_position': True},
|
||||
'snare_roll': {'template': '*Snare Roll*.wav', 'pre_beats': 4},
|
||||
}
|
||||
|
||||
def auto_riser_before_drop(self, section_start: float, n_beats: int = 8) -> Optional[Dict]:
|
||||
"""T055: Genera riser N beats antes de drop."""
|
||||
return {
|
||||
'type': 'riser',
|
||||
'position': max(0, section_start - n_beats),
|
||||
'duration': n_beats,
|
||||
'template': self.fx_patterns['riser']['template']
|
||||
}
|
||||
|
||||
def auto_downlifter_transition(self, from_section: str, to_section: str,
|
||||
section_end: float) -> Optional[Dict]:
|
||||
"""T056: Auto-downlifter en transiciones."""
|
||||
if to_section in ['drop', 'break'] and from_section in ['build', 'drop']:
|
||||
return {
|
||||
'type': 'downlifter',
|
||||
'position': section_end - 2,
|
||||
'duration': 2,
|
||||
'template': self.fx_patterns['downlifter']['template']
|
||||
}
|
||||
return None
|
||||
|
||||
def auto_impact_on_downbeat(self, section_start: float, section_kind: str) -> Optional[Dict]:
|
||||
"""T057: Impact/crash en downbeats de drop."""
|
||||
if section_kind in ['drop', 'build']:
|
||||
return {
|
||||
'type': 'impact',
|
||||
'position': section_start,
|
||||
'template': self.fx_patterns['impact']['template']
|
||||
}
|
||||
return None
|
||||
|
||||
def auto_snare_roll(self, section_start: float, duration_beats: int = 4) -> Optional[Dict]:
|
||||
"""T058: Snare roll automático antes de drops."""
|
||||
return {
|
||||
'type': 'snare_roll',
|
||||
'position': max(0, section_start - duration_beats),
|
||||
'duration': duration_beats,
|
||||
'template': self.fx_patterns['snare_roll']['template']
|
||||
}
|
||||
|
||||
|
||||
class TonalAnalyzer:
|
||||
"""T059-T062: Análisis de conflictos tonales"""
|
||||
|
||||
NOTE_NAMES = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B']
|
||||
|
||||
def detect_key_conflict(self, samples: List[Dict], target_key: str) -> List[Dict]:
|
||||
"""T059: Detecta si samples tienen key conflict con target_key."""
|
||||
conflicts = []
|
||||
for sample in samples:
|
||||
sample_key = sample.get('key', '')
|
||||
if sample_key and sample_key != target_key:
|
||||
# Check compatibility using circle of fifths
|
||||
distance = self._key_distance(target_key, sample_key)
|
||||
if distance > 2: # More than 2 steps on circle
|
||||
conflicts.append({
|
||||
'sample': sample.get('path', 'unknown'),
|
||||
'sample_key': sample_key,
|
||||
'target_key': target_key,
|
||||
'distance': distance,
|
||||
'severity': 'high' if distance > 4 else 'medium'
|
||||
})
|
||||
return conflicts
|
||||
|
||||
def _key_distance(self, key1: str, key2: str) -> int:
|
||||
"""Calcula distancia en círculo de quintas."""
|
||||
# Normalize keys
|
||||
is_minor1 = 'm' in key1.lower()
|
||||
is_minor2 = 'm' in key2.lower()
|
||||
|
||||
if is_minor1 != is_minor2:
|
||||
return 6 # Different modes = max distance
|
||||
|
||||
root1 = key1.replace('m', '').replace('M', '')
|
||||
root2 = key2.replace('m', '').replace('M', '')
|
||||
|
||||
try:
|
||||
idx1 = self.NOTE_NAMES.index(root1)
|
||||
idx2 = self.NOTE_NAMES.index(root2)
|
||||
except ValueError:
|
||||
return 6 # Unknown note
|
||||
|
||||
# Distance on circle of fifths
|
||||
circle_of_fifths = [0, 7, 2, 9, 4, 11, 6, 1, 8, 3, 10, 5] # Perfect fifths order
|
||||
pos1 = circle_of_fifths.index(idx1) if idx1 in circle_of_fifths else 0
|
||||
pos2 = circle_of_fifths.index(idx2) if idx2 in circle_of_fifths else 0
|
||||
|
||||
return min(abs(pos1 - pos2), 12 - abs(pos1 - pos2))
|
||||
|
||||
def suggest_transpose(self, sample_path: str, from_key: str, to_key: str) -> int:
|
||||
"""T060-T061: Sugiere semitonos para transponer sample a key objetivo."""
|
||||
try:
|
||||
root_from = from_key.replace('m', '').replace('M', '')
|
||||
root_to = to_key.replace('m', '').replace('M', '')
|
||||
|
||||
idx_from = self.NOTE_NAMES.index(root_from)
|
||||
idx_to = self.NOTE_NAMES.index(root_to)
|
||||
|
||||
semitones = idx_to - idx_from
|
||||
# Normalize to -6 to +6 range
|
||||
if semitones > 6:
|
||||
semitones -= 12
|
||||
elif semitones < -6:
|
||||
semitones += 12
|
||||
|
||||
return semitones
|
||||
except ValueError:
|
||||
return 0 # Can't calculate
|
||||
|
||||
def generate_dissonance_alert(self, conflicts: List[Dict]) -> str:
|
||||
"""T062: Genera alertas de disonancia."""
|
||||
if not conflicts:
|
||||
return "No tonal conflicts detected."
|
||||
|
||||
high_conflicts = [c for c in conflicts if c['severity'] == 'high']
|
||||
if high_conflicts:
|
||||
return f"WARNING: {len(high_conflicts)} high-severity key conflicts detected!"
|
||||
return f"INFO: {len(conflicts)} minor key variations (acceptable)."
|
||||
143
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/benchmark.py
Normal file
143
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/benchmark.py
Normal file
@@ -0,0 +1,143 @@
|
||||
"""
|
||||
benchmark.py - Performance profiling de generación
|
||||
T107-T110: Benchmarking y profiling
|
||||
"""
|
||||
import time
|
||||
import logging
|
||||
from typing import Dict, Any, List
|
||||
from statistics import mean, stdev
|
||||
|
||||
logging.basicConfig(level=logging.INFO)
|
||||
logger = logging.getLogger("Benchmark")
|
||||
|
||||
|
||||
class PerformanceBenchmark:
|
||||
"""Benchmark de rendimiento del sistema."""
|
||||
|
||||
def __init__(self):
|
||||
self.results: Dict[str, List[float]] = {}
|
||||
|
||||
def benchmark_generation(self, n_runs: int = 5) -> Dict[str, Any]:
|
||||
"""
|
||||
Benchmark de generación completa.
|
||||
|
||||
Args:
|
||||
n_runs: Número de ejecuciones
|
||||
|
||||
Returns:
|
||||
Estadísticas de rendimiento
|
||||
"""
|
||||
from full_integration import generate_complete_track
|
||||
|
||||
times = []
|
||||
|
||||
for i in range(n_runs):
|
||||
start = time.time()
|
||||
result = generate_complete_track("techno", seed=1000 + i)
|
||||
elapsed = time.time() - start
|
||||
times.append(elapsed)
|
||||
logger.info(f"Run {i+1}/{n_runs}: {elapsed:.2f}s")
|
||||
|
||||
return {
|
||||
'operation': 'full_generation',
|
||||
'n_runs': n_runs,
|
||||
'mean_time': mean(times),
|
||||
'stdev_time': stdev(times) if len(times) > 1 else 0,
|
||||
'min_time': min(times),
|
||||
'max_time': max(times),
|
||||
'total_time': sum(times),
|
||||
}
|
||||
|
||||
def benchmark_component(self, component_name: str, func, *args, n_runs: int = 10) -> Dict[str, Any]:
|
||||
"""Benchmark de componente específico."""
|
||||
times = []
|
||||
|
||||
for _ in range(n_runs):
|
||||
start = time.time()
|
||||
func(*args)
|
||||
elapsed = time.time() - start
|
||||
times.append(elapsed)
|
||||
|
||||
return {
|
||||
'component': component_name,
|
||||
'n_runs': n_runs,
|
||||
'mean_time': mean(times),
|
||||
'min_time': min(times),
|
||||
'max_time': max(times),
|
||||
}
|
||||
|
||||
def run_full_benchmark(self) -> Dict[str, Any]:
|
||||
"""Ejecuta benchmark completo de todos los componentes."""
|
||||
results = {}
|
||||
|
||||
# Benchmark generación completa
|
||||
logger.info("Benchmarking full generation...")
|
||||
results['full_generation'] = self.benchmark_generation(n_runs=3)
|
||||
|
||||
# Benchmark HumanFeelEngine
|
||||
logger.info("Benchmarking HumanFeelEngine...")
|
||||
from human_feel import HumanFeelEngine
|
||||
engine = HumanFeelEngine(seed=42)
|
||||
notes = [{'pitch': 60, 'start': float(i), 'velocity': 100} for i in range(100)]
|
||||
results['human_feel'] = self.benchmark_component(
|
||||
'HumanFeelEngine.process_notes',
|
||||
engine.process_notes,
|
||||
notes, 'drop', True, 'shuffle',
|
||||
n_runs=100
|
||||
)
|
||||
|
||||
# Benchmark AutoPrompter
|
||||
logger.info("Benchmarking AutoPrompter...")
|
||||
from self_ai import AutoPrompter
|
||||
prompter = AutoPrompter()
|
||||
vibes = ["techno", "house", "trance", "drum and bass", "deep house"]
|
||||
results['auto_prompter'] = self.benchmark_component(
|
||||
'AutoPrompter.generate_from_vibe',
|
||||
lambda: [prompter.generate_from_vibe(v) for v in vibes],
|
||||
n_runs=10
|
||||
)
|
||||
|
||||
# Benchmark DJArrangementEngine
|
||||
logger.info("Benchmarking DJArrangementEngine...")
|
||||
from audio_arrangement import DJArrangementEngine
|
||||
arr_engine = DJArrangementEngine(seed=42)
|
||||
results['arrangement'] = self.benchmark_component(
|
||||
'DJArrangementEngine.generate_structure',
|
||||
arr_engine.generate_structure,
|
||||
'standard',
|
||||
n_runs=50
|
||||
)
|
||||
|
||||
# Summary
|
||||
logger.info("\n" + "="*50)
|
||||
logger.info("BENCHMARK SUMMARY")
|
||||
logger.info("="*50)
|
||||
for name, data in results.items():
|
||||
if 'mean_time' in data:
|
||||
logger.info(f"{name}: {data['mean_time']:.4f}s (avg)")
|
||||
|
||||
return results
|
||||
|
||||
|
||||
def main():
|
||||
"""Ejecuta benchmark desde línea de comandos."""
|
||||
import sys
|
||||
|
||||
n_runs = int(sys.argv[1]) if len(sys.argv) > 1 else 3
|
||||
|
||||
benchmark = PerformanceBenchmark()
|
||||
results = benchmark.run_full_benchmark()
|
||||
|
||||
# Guardar resultados
|
||||
import json
|
||||
from pathlib import Path
|
||||
|
||||
output_path = Path("benchmark_results.json")
|
||||
with open(output_path, 'w') as f:
|
||||
json.dump(results, f, indent=2)
|
||||
|
||||
logger.info(f"\nResults saved to {output_path}")
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
278
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/bus_routing_fix.py
Normal file
278
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/bus_routing_fix.py
Normal file
@@ -0,0 +1,278 @@
|
||||
"""
|
||||
bus_routing_fix.py - Fix de enrutamiento de buses
|
||||
T101-T104: Bus Routing System Fix
|
||||
|
||||
Problemas a resolver:
|
||||
- Drums van a drum rack pero también a master
|
||||
- FX no llegan a los returns correctos
|
||||
- Vocal chops en bus de FX en lugar de Vocal
|
||||
"""
|
||||
import logging
|
||||
from typing import Dict, Any, List, Optional
|
||||
from dataclasses import dataclass
|
||||
|
||||
logger = logging.getLogger("BusRoutingFix")
|
||||
|
||||
|
||||
@dataclass
|
||||
class BusRoute:
|
||||
"""Definición de ruta de bus"""
|
||||
source_track: str
|
||||
target_bus: str
|
||||
send_level: float = 0.0 # 0.0 = no send, 1.0 = full send
|
||||
should_go_to_master: bool = True
|
||||
|
||||
|
||||
class BusRoutingRules:
|
||||
"""T101: Reglas de enrutamiento por tipo de track"""
|
||||
|
||||
# Mapeo de roles a buses
|
||||
ROLE_TO_BUS = {
|
||||
'kick': 'drums',
|
||||
'clap': 'drums',
|
||||
'snare': 'drums',
|
||||
'hat': 'drums',
|
||||
'perc': 'drums',
|
||||
'ride': 'drums',
|
||||
'top_loop': 'drums',
|
||||
'drum_loop': 'drums',
|
||||
'breakbeat': 'drums',
|
||||
'sub_bass': 'bass',
|
||||
'bass': 'bass',
|
||||
'bass_loop': 'bass',
|
||||
'chords': 'music',
|
||||
'pad': 'music',
|
||||
'pluck': 'music',
|
||||
'arp': 'music',
|
||||
'lead': 'music',
|
||||
'counter': 'music',
|
||||
'synth': 'music',
|
||||
'vocal': 'vocal',
|
||||
'vocal_chop': 'vocal',
|
||||
'vox': 'vocal',
|
||||
'voice': 'vocal',
|
||||
'riser': 'fx',
|
||||
'downlifter': 'fx',
|
||||
'impact': 'fx',
|
||||
'crash': 'fx',
|
||||
'atmos': 'fx',
|
||||
'reverse_fx': 'fx',
|
||||
'texture': 'fx',
|
||||
}
|
||||
|
||||
# Buses RCA disponibles
|
||||
RCA_BUSES = ['drums', 'bass', 'music', 'vocal', 'fx']
|
||||
|
||||
# Returns configurados en Live
|
||||
RETURN_TRACKS = ['Reverb', 'Delay', 'Chorus', 'Spatial']
|
||||
|
||||
@classmethod
|
||||
def get_bus_for_role(cls, role: str) -> str:
|
||||
"""Retorna el bus RCA apropiado para un rol."""
|
||||
role_lower = role.lower().replace('_loop', '').replace('loop_', '')
|
||||
|
||||
# Check direct match
|
||||
if role_lower in cls.ROLE_TO_BUS:
|
||||
return cls.ROLE_TO_BUS[role_lower]
|
||||
|
||||
# Check partial match
|
||||
for key, bus in cls.ROLE_TO_BUS.items():
|
||||
if key in role_lower or role_lower in key:
|
||||
return bus
|
||||
|
||||
# Default por categoría
|
||||
if any(d in role_lower for d in ['drum', 'kick', 'snare', 'hat', 'perc']):
|
||||
return 'drums'
|
||||
if any(b in role_lower for b in ['bass', 'sub', '808', 'low']):
|
||||
return 'bass'
|
||||
if any(s in role_lower for s in ['synth', 'pad', 'chord', 'lead', 'pluck', 'melody']):
|
||||
return 'music'
|
||||
if any(v in role_lower for v in ['vocal', 'vox', 'voice', 'chant']):
|
||||
return 'vocal'
|
||||
if any(f in role_lower for f in ['fx', 'riser', 'impact', 'atmos', 'texture', 'noise']):
|
||||
return 'fx'
|
||||
|
||||
return 'music' # Default fallback
|
||||
|
||||
|
||||
class BusRoutingFixer:
|
||||
"""T102-T104: Aplica fixes de enrutamiento"""
|
||||
|
||||
def __init__(self):
|
||||
self.rules = BusRoutingRules()
|
||||
self.issues_found: List[Dict] = []
|
||||
self.fixes_applied: List[Dict] = []
|
||||
|
||||
def diagnose_routing(self, tracks_data: List[Dict]) -> List[Dict]:
|
||||
"""
|
||||
T102: Diagnostica problemas de enrutamiento.
|
||||
|
||||
Args:
|
||||
tracks_data: Lista de tracks con sus configuraciones
|
||||
|
||||
Returns:
|
||||
Lista de problemas encontrados
|
||||
"""
|
||||
issues = []
|
||||
|
||||
for track in tracks_data:
|
||||
track_name = track.get('name', 'Unknown')
|
||||
track_role = track.get('role', '')
|
||||
current_bus = track.get('output_bus', 'master')
|
||||
|
||||
# Determinar bus correcto
|
||||
correct_bus = self.rules.get_bus_for_role(track_role or track_name)
|
||||
|
||||
# Verificar si está en bus incorrecto
|
||||
if current_bus != correct_bus and current_bus != 'master':
|
||||
issues.append({
|
||||
'track': track_name,
|
||||
'role': track_role,
|
||||
'current_bus': current_bus,
|
||||
'correct_bus': correct_bus,
|
||||
'issue': 'wrong_bus',
|
||||
'severity': 'high' if correct_bus != 'music' else 'medium'
|
||||
})
|
||||
|
||||
# Verificar sends incorrectos (ej: drums enviando a reverb fuerte)
|
||||
sends = track.get('sends', {})
|
||||
if track_role in ['kick', 'sub_bass']:
|
||||
reverb_send = sends.get('Reverb', 0)
|
||||
if reverb_send > 0.3:
|
||||
issues.append({
|
||||
'track': track_name,
|
||||
'role': track_role,
|
||||
'issue': 'excessive_reverb_on_low',
|
||||
'current_send': reverb_send,
|
||||
'recommended': 0.1,
|
||||
'severity': 'medium'
|
||||
})
|
||||
|
||||
# Verificar que FX tracks no van a master directo
|
||||
if correct_bus == 'fx' and track.get('audio_output') == 'Master':
|
||||
issues.append({
|
||||
'track': track_name,
|
||||
'role': track_role,
|
||||
'issue': 'fx_to_master_bypass',
|
||||
'severity': 'low'
|
||||
})
|
||||
|
||||
self.issues_found = issues
|
||||
return issues
|
||||
|
||||
def apply_routing_fixes(self, ableton_connection, tracks_data: List[Dict]) -> Dict:
|
||||
"""
|
||||
T103: Aplica fixes de enrutamiento en Ableton.
|
||||
|
||||
Args:
|
||||
ableton_connection: Conexión a Ableton Live
|
||||
tracks_data: Datos de tracks a corregir
|
||||
|
||||
Returns:
|
||||
Reporte de fixes aplicados
|
||||
"""
|
||||
fixes = []
|
||||
|
||||
for track in tracks_data:
|
||||
track_name = track.get('name')
|
||||
track_index = track.get('index')
|
||||
track_role = track.get('role', '')
|
||||
|
||||
# Determinar bus correcto
|
||||
correct_bus = self.rules.get_bus_for_role(track_role or track_name)
|
||||
|
||||
try:
|
||||
# 1. Cambiar output del track al bus RCA
|
||||
# Esto requiere que los buses RCA existan como tracks de audio
|
||||
self._set_track_output(ableton_connection, track_index, correct_bus)
|
||||
|
||||
# 2. Ajustar sends si es necesario
|
||||
if track_role in ['kick', 'sub_bass']:
|
||||
self._adjust_send(ableton_connection, track_index, 'Reverb', 0.1)
|
||||
|
||||
fixes.append({
|
||||
'track': track_name,
|
||||
'action': f'routed_to_{correct_bus}',
|
||||
'success': True
|
||||
})
|
||||
|
||||
except Exception as e:
|
||||
fixes.append({
|
||||
'track': track_name,
|
||||
'action': 'routing_fix',
|
||||
'success': False,
|
||||
'error': str(e)
|
||||
})
|
||||
|
||||
self.fixes_applied = fixes
|
||||
return {
|
||||
'total_tracks': len(tracks_data),
|
||||
'fixes_applied': len([f for f in fixes if f.get('success')]),
|
||||
'fixes_failed': len([f for f in fixes if not f.get('success')]),
|
||||
'details': fixes
|
||||
}
|
||||
|
||||
def _set_track_output(self, ableton_connection, track_index: int, output_bus: str):
|
||||
"""Setea output de un track a un bus específico."""
|
||||
# Comando MCP para cambiar output
|
||||
cmd = {
|
||||
'command': 'set_track_output',
|
||||
'track_index': track_index,
|
||||
'output': output_bus
|
||||
}
|
||||
ableton_connection.send_command(cmd)
|
||||
|
||||
def _adjust_send(self, ableton_connection, track_index: int, send_name: str, level: float):
|
||||
"""Ajusta nivel de send."""
|
||||
cmd = {
|
||||
'command': 'set_send_level',
|
||||
'track_index': track_index,
|
||||
'send_name': send_name,
|
||||
'level': level
|
||||
}
|
||||
ableton_connection.send_command(cmd)
|
||||
|
||||
def validate_routing(self, tracks_data: List[Dict]) -> Dict:
|
||||
"""
|
||||
T104: Valida que el enrutamiento esté correcto.
|
||||
|
||||
Returns:
|
||||
Reporte de validación
|
||||
"""
|
||||
issues = self.diagnose_routing(tracks_data)
|
||||
|
||||
critical = [i for i in issues if i.get('severity') == 'high']
|
||||
warnings = [i for i in issues if i.get('severity') in ['medium', 'low']]
|
||||
|
||||
return {
|
||||
'valid': len(critical) == 0,
|
||||
'critical_issues': len(critical),
|
||||
'warnings': len(warnings),
|
||||
'total_issues': len(issues),
|
||||
'issues': issues
|
||||
}
|
||||
|
||||
def get_bus_routing_config(self) -> Dict[str, Any]:
|
||||
"""Retorna configuración completa de enrutamiento."""
|
||||
return {
|
||||
'buses': self.rules.RCA_BUSES,
|
||||
'returns': self.rules.RETURN_TRACKS,
|
||||
'role_mapping': self.rules.ROLE_TO_BUS,
|
||||
'validation_rules': {
|
||||
'kick_reverb_max': 0.1,
|
||||
'sub_bass_reverb_max': 0.05,
|
||||
'drums_to_fx_send': 0.0,
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
# Instancia global
|
||||
_routing_fixer: Optional[BusRoutingFixer] = None
|
||||
|
||||
|
||||
def get_routing_fixer() -> BusRoutingFixer:
|
||||
"""Obtiene instancia global del fixer."""
|
||||
global _routing_fixer
|
||||
if _routing_fixer is None:
|
||||
_routing_fixer = BusRoutingFixer()
|
||||
return _routing_fixer
|
||||
381
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/diversity_memory.py
Normal file
381
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/diversity_memory.py
Normal file
@@ -0,0 +1,381 @@
|
||||
"""
|
||||
diversity_memory.py - Sistema de memoria de diversidad entre generaciones
|
||||
|
||||
Persistencia cross-generation para evitar repetición de familias de samples.
|
||||
Incluye TTL automático, penalización acumulativa y thread-safety.
|
||||
"""
|
||||
|
||||
import json
|
||||
import logging
|
||||
import os
|
||||
import threading
|
||||
from collections import defaultdict
|
||||
from pathlib import Path
|
||||
from typing import Dict, List, Optional, Tuple, Any
|
||||
from datetime import datetime
|
||||
|
||||
logger = logging.getLogger("DiversityMemory")
|
||||
|
||||
# =============================================================================
|
||||
# CONFIGURACIÓN
|
||||
# =============================================================================
|
||||
|
||||
DIVERSITY_MEMORY_FILE = "diversity_memory.json"
|
||||
MAX_GENERATIONS_TTL = 10 # Familias expiran después de 10 generaciones
|
||||
CRITICAL_ROLES = {'kick', 'clap', 'hat', 'hat_closed', 'hat_open', 'bass_loop', 'vocal_loop', 'top_loop'}
|
||||
|
||||
# Fórmula de penalización acumulativa
|
||||
# 0 usos → 1.0 (sin penalización)
|
||||
# 1 uso → 0.7 (penalización leve)
|
||||
# 2 usos → 0.5 (penalización media)
|
||||
# 3+ usos → 0.3 (penalización fuerte)
|
||||
PENALTY_FORMULA = {0: 1.0, 1: 0.7, 2: 0.5, 3: 0.3}
|
||||
MAX_PENALTY = 0.3
|
||||
|
||||
# Keywords para detección de familias
|
||||
FAMILY_KEYWORDS = {
|
||||
# Drums por tipo de máquina
|
||||
'808': ['808', 'tr808', 'tr-808', 'eight-oh-eight'],
|
||||
'909': ['909', 'tr909', 'tr-909', 'nine-oh-nine'],
|
||||
'707': ['707', 'tr707'],
|
||||
'606': ['606', 'tr606'],
|
||||
'acoustic': ['acoustic', 'real', 'live', 'studio', 'analog_real'],
|
||||
'vinyl': ['vinyl', 'vin', 'recorded', 'sampled_drum'],
|
||||
'digital': ['digital', 'digi', 'synthetic', 'synth', 'electronic'],
|
||||
'analog': ['analog', 'analogue', 'moog', 'oberheim', 'sequential'],
|
||||
# Bass por tipo
|
||||
'reese': ['reese', 'reese_bass'],
|
||||
'acid': ['acid', '303', 'tb303', 'bassline'],
|
||||
'sub': ['sub', 'subby', 'sub_bass'],
|
||||
'growl': ['growl', 'wobble', 'dubstep'],
|
||||
# Vocals por estilo
|
||||
'vocal_chop': ['chop', 'chopped', 'stutter'],
|
||||
'vocal_phrase': ['phrase', 'hook', 'shout'],
|
||||
'vocal_verse': ['verse', 'acapella', 'acappella'],
|
||||
# Loops por textura
|
||||
'percu_shaker': ['shaker', 'shake'],
|
||||
'percu_conga': ['conga', 'bongo', 'latin'],
|
||||
'percu_tribal': ['tribal', 'ethnic', 'world'],
|
||||
}
|
||||
|
||||
# =============================================================================
|
||||
# ESTRUCTURA DE DATOS
|
||||
# =============================================================================
|
||||
|
||||
class DiversityMemory:
|
||||
"""Memoria thread-safe de diversidad con persistencia JSON."""
|
||||
|
||||
def __init__(self, project_dir: Optional[Path] = None):
|
||||
"""
|
||||
Inicializa la memoria de diversidad.
|
||||
|
||||
Args:
|
||||
project_dir: Directorio del proyecto para guardar el archivo JSON
|
||||
"""
|
||||
self._lock = threading.RLock()
|
||||
|
||||
# Determinar directorio del proyecto
|
||||
if project_dir is None:
|
||||
# Buscar en directorios conocidos
|
||||
possible_dirs = [
|
||||
Path(__file__).parent.parent, # MCP_Server/../
|
||||
Path.home() / "Documents" / "AbletonMCP_AI",
|
||||
Path(os.getcwd()),
|
||||
]
|
||||
for pd in possible_dirs:
|
||||
if pd.exists() and pd.is_dir():
|
||||
project_dir = pd
|
||||
break
|
||||
|
||||
self._file_path = (project_dir / DIVERSITY_MEMORY_FILE) if project_dir else Path(DIVERSITY_MEMORY_FILE)
|
||||
|
||||
# Datos en memoria
|
||||
self._used_families: Dict[str, int] = defaultdict(int)
|
||||
self._used_paths: Dict[str, int] = defaultdict(int)
|
||||
self._generation_count: int = 0
|
||||
self._last_updated: str = datetime.now().isoformat()
|
||||
|
||||
# Cargar datos existentes
|
||||
self._load()
|
||||
|
||||
def _load(self) -> None:
|
||||
"""Carga la memoria desde el archivo JSON."""
|
||||
if self._file_path.exists():
|
||||
try:
|
||||
with open(self._file_path, 'r', encoding='utf-8') as f:
|
||||
data = json.load(f)
|
||||
|
||||
self._used_families = defaultdict(int, data.get('used_families', {}))
|
||||
self._used_paths = defaultdict(int, data.get('used_paths', {}))
|
||||
self._generation_count = data.get('generation_count', 0)
|
||||
self._last_updated = data.get('last_updated', datetime.now().isoformat())
|
||||
|
||||
logger.debug(f"DiversityMemory cargada desde {self._file_path}")
|
||||
logger.debug(f" - Familias usadas: {len(self._used_families)}")
|
||||
logger.debug(f" - Paths usados: {len(self._used_paths)}")
|
||||
logger.debug(f" - Generación #{self._generation_count}")
|
||||
except Exception as e:
|
||||
logger.warning(f"Error cargando diversity_memory.json: {e}")
|
||||
# Resetear a valores por defecto
|
||||
self._reset_data()
|
||||
else:
|
||||
logger.debug(f"Archivo {self._file_path} no existe, iniciando memoria vacía")
|
||||
|
||||
def _save(self) -> None:
|
||||
"""Guarda la memoria al archivo JSON."""
|
||||
with self._lock:
|
||||
data = {
|
||||
'used_families': dict(self._used_families),
|
||||
'used_paths': dict(self._used_paths),
|
||||
'generation_count': self._generation_count,
|
||||
'last_updated': datetime.now().isoformat(),
|
||||
'version': '1.0'
|
||||
}
|
||||
|
||||
try:
|
||||
# Crear directorio si no existe
|
||||
self._file_path.parent.mkdir(parents=True, exist_ok=True)
|
||||
|
||||
with open(self._file_path, 'w', encoding='utf-8') as f:
|
||||
json.dump(data, f, indent=2, ensure_ascii=False)
|
||||
|
||||
logger.debug(f"DiversityMemory guardada en {self._file_path}")
|
||||
except Exception as e:
|
||||
logger.error(f"Error guardando diversity_memory.json: {e}")
|
||||
|
||||
def _reset_data(self) -> None:
|
||||
"""Resetea los datos a valores iniciales."""
|
||||
self._used_families.clear()
|
||||
self._used_paths.clear()
|
||||
self._generation_count = 0
|
||||
self._last_updated = datetime.now().isoformat()
|
||||
|
||||
def record_sample_usage(self, role: str, sample_path: str, sample_name: str) -> None:
|
||||
"""
|
||||
Registra el uso de un sample en esta generación.
|
||||
|
||||
Args:
|
||||
role: Rol del sample (ej: 'kick', 'clap')
|
||||
sample_path: Path completo al archivo
|
||||
sample_name: Nombre del archivo
|
||||
"""
|
||||
if role not in CRITICAL_ROLES:
|
||||
return # Solo tracking de roles críticos
|
||||
|
||||
with self._lock:
|
||||
family = self._detect_family(sample_path, sample_name)
|
||||
|
||||
if family:
|
||||
self._used_families[family] += 1
|
||||
logger.debug(f"Registrada familia '{family}' para rol '{role}' (usos: {self._used_families[family]})")
|
||||
|
||||
# Siempre registrar el path
|
||||
self._used_paths[sample_path] += 1
|
||||
|
||||
def record_generation_complete(self) -> None:
|
||||
"""
|
||||
Marca el fin de una generación y aplica TTL.
|
||||
Decrementa contadores y elimina familias expiradas.
|
||||
"""
|
||||
with self._lock:
|
||||
self._generation_count += 1
|
||||
|
||||
# Aplicar TTL a familias
|
||||
families_to_remove = []
|
||||
for family, count in self._used_families.items():
|
||||
if count > 0:
|
||||
# TTL: después de MAX_GENERATIONS_TTL, eliminar familia
|
||||
if count >= MAX_GENERATIONS_TTL:
|
||||
families_to_remove.append(family)
|
||||
# Penalización decreciente con el tiempo
|
||||
# En cada generación sin uso, reduce el conteo
|
||||
# (simula decaimiento)
|
||||
|
||||
# Remover familias expiradas
|
||||
for family in families_to_remove:
|
||||
del self._used_families[family]
|
||||
logger.debug(f"Familia '{family}' expirada después de {MAX_GENERATIONS_TTL} generaciones")
|
||||
|
||||
# Guardar después de cada generación
|
||||
self._save()
|
||||
|
||||
logger.info(f"Generación #{self._generation_count} completada. "
|
||||
f"Familias activas: {len(self._used_families)}")
|
||||
|
||||
def get_penalty_for_sample(self, role: str, sample_path: str, sample_name: str) -> float:
|
||||
"""
|
||||
Calcula la penalización para un sample específico.
|
||||
|
||||
Returns:
|
||||
float entre 0.0 y 1.0 (multiplicar el score original por este factor)
|
||||
1.0 = sin penalización
|
||||
0.3 = penalización máxima
|
||||
"""
|
||||
if role not in CRITICAL_ROLES:
|
||||
return 1.0 # Sin penalización para roles no críticos
|
||||
|
||||
with self._lock:
|
||||
family = self._detect_family(sample_path, sample_name)
|
||||
family_uses = self._used_families.get(family, 0) if family else 0
|
||||
path_uses = self._used_paths.get(sample_path, 0)
|
||||
|
||||
# Penalización por familia (acumulativa)
|
||||
if family_uses >= 3:
|
||||
family_penalty = MAX_PENALTY
|
||||
elif family_uses > 0:
|
||||
family_penalty = PENALTY_FORMULA.get(family_uses, MAX_PENALTY)
|
||||
else:
|
||||
family_penalty = 1.0
|
||||
|
||||
# Penalización adicional por path específico (evitar repetición exacta)
|
||||
if path_uses >= 2:
|
||||
path_penalty = 0.5
|
||||
elif path_uses == 1:
|
||||
path_penalty = 0.8
|
||||
else:
|
||||
path_penalty = 1.0
|
||||
|
||||
total_penalty = family_penalty * path_penalty
|
||||
|
||||
if total_penalty < 1.0:
|
||||
logger.debug(f"Penalización para '{sample_name}': {total_penalty:.2f} "
|
||||
f"(familia: {family_penalty:.2f} [{family_uses} usos], "
|
||||
f"path: {path_penalty:.2f} [{path_uses} usos])")
|
||||
|
||||
return total_penalty
|
||||
|
||||
def _detect_family(self, sample_path: str, sample_name: str) -> Optional[str]:
|
||||
"""
|
||||
Detecta la familia de un sample basado en path y nombre.
|
||||
|
||||
Estrategias (en orden de prioridad):
|
||||
1. Keywords en el nombre del archivo
|
||||
2. Directorio padre
|
||||
3. Path completo
|
||||
|
||||
Returns:
|
||||
Nombre de la familia o None si no se detecta
|
||||
"""
|
||||
path_lower = sample_path.lower()
|
||||
name_lower = sample_name.lower()
|
||||
|
||||
# 1. Buscar keywords en nombre
|
||||
for family, keywords in FAMILY_KEYWORDS.items():
|
||||
for kw in keywords:
|
||||
if kw in name_lower:
|
||||
return family
|
||||
|
||||
# 2. Buscar en directorio padre
|
||||
# Ej: "808_Kicks/kick_808_warm.wav" → familia "808"
|
||||
parent_dir = Path(sample_path).parent.name.lower() if sample_path else ""
|
||||
for family, keywords in FAMILY_KEYWORDS.items():
|
||||
for kw in keywords:
|
||||
if kw in parent_dir:
|
||||
return family
|
||||
|
||||
# 3. Buscar en path completo
|
||||
for family, keywords in FAMILY_KEYWORDS.items():
|
||||
for kw in keywords:
|
||||
if kw in path_lower:
|
||||
return family
|
||||
|
||||
# Si no hay coincidencia, devolver None
|
||||
return None
|
||||
|
||||
def get_stats(self) -> Dict[str, Any]:
|
||||
"""
|
||||
Retorna estadísticas de la memoria de diversidad.
|
||||
|
||||
Returns:
|
||||
Dict con:
|
||||
- used_families: dict de familias y conteos
|
||||
- total_families: int
|
||||
- used_paths: dict de paths y conteos
|
||||
- total_paths: int
|
||||
- generation_count: int
|
||||
- file_location: str
|
||||
"""
|
||||
with self._lock:
|
||||
return {
|
||||
'used_families': dict(self._used_families),
|
||||
'total_families': len(self._used_families),
|
||||
'used_paths': dict(self._used_paths),
|
||||
'total_paths': len(self._used_paths),
|
||||
'generation_count': self._generation_count,
|
||||
'critical_roles': list(CRITICAL_ROLES),
|
||||
'file_location': str(self._file_path.absolute()) if self._file_path.exists() else None,
|
||||
'max_generations_ttl': MAX_GENERATIONS_TTL,
|
||||
'penalty_formula': PENALTY_FORMULA,
|
||||
}
|
||||
|
||||
def reset(self) -> None:
|
||||
"""Limpia toda la memoria de diversidad."""
|
||||
with self._lock:
|
||||
self._reset_data()
|
||||
self._save()
|
||||
logger.info("DiversityMemory reseteada completamente")
|
||||
|
||||
|
||||
# =============================================================================
|
||||
# INSTANCIA GLOBAL
|
||||
# =============================================================================
|
||||
|
||||
# Instancia singleton (thread-safe por el lock interno)
|
||||
_diversity_memory: Optional[DiversityMemory] = None
|
||||
|
||||
|
||||
def get_diversity_memory(project_dir: Optional[Path] = None) -> DiversityMemory:
|
||||
"""Obtiene la instancia global de DiversityMemory."""
|
||||
global _diversity_memory
|
||||
if _diversity_memory is None:
|
||||
_diversity_memory = DiversityMemory(project_dir)
|
||||
return _diversity_memory
|
||||
|
||||
|
||||
def reset_diversity_memory() -> None:
|
||||
"""API: Limpia la memoria de diversidad."""
|
||||
memory = get_diversity_memory()
|
||||
memory.reset()
|
||||
|
||||
|
||||
def get_diversity_memory_stats() -> Dict[str, Any]:
|
||||
"""API: Obtiene estadísticas de la memoria."""
|
||||
memory = get_diversity_memory()
|
||||
return memory.get_stats()
|
||||
|
||||
|
||||
def record_sample_usage(role: str, sample_path: str, sample_name: str) -> None:
|
||||
"""API: Registra uso de un sample."""
|
||||
memory = get_diversity_memory()
|
||||
memory.record_sample_usage(role, sample_path, sample_name)
|
||||
|
||||
|
||||
def record_generation_complete() -> None:
|
||||
"""API: Marca fin de generación y aplica TTL."""
|
||||
memory = get_diversity_memory()
|
||||
memory.record_generation_complete()
|
||||
|
||||
|
||||
def get_penalty_for_sample(role: str, sample_path: str, sample_name: str) -> float:
|
||||
"""API: Obtiene penalización para un sample."""
|
||||
memory = get_diversity_memory()
|
||||
return memory.get_penalty_for_sample(role, sample_path, sample_name)
|
||||
|
||||
|
||||
# =============================================================================
|
||||
# FUNCIÓN DE AYUDA PARA DETECCIÓN EXTERNA
|
||||
# =============================================================================
|
||||
|
||||
def detect_sample_family(sample_path: str, sample_name: str) -> Optional[str]:
|
||||
"""
|
||||
Detecta la familia de un sample (función pública).
|
||||
Usa la misma lógica que DiversityMemory.
|
||||
"""
|
||||
memory = get_diversity_memory()
|
||||
return memory._detect_family(sample_path, sample_name)
|
||||
|
||||
|
||||
# Familias conocidas para referencia
|
||||
def get_known_families() -> Dict[str, List[str]]:
|
||||
"""Retorna las familias de samples conocidas con sus keywords."""
|
||||
return FAMILY_KEYWORDS.copy()
|
||||
@@ -0,0 +1,431 @@
|
||||
"""
|
||||
Enhanced Device Automation for Timbral Movement Between Sections.
|
||||
This module provides expanded device automation parameters for musical variation.
|
||||
"""
|
||||
|
||||
# =============================================================================
|
||||
# ENHANCED SECTION DEVICE AUTOMATION - More timbral color per section
|
||||
# =============================================================================
|
||||
|
||||
# Automatizacion de devices en tracks individuales por rol - ENHANCED
|
||||
SECTION_DEVICE_AUTOMATION = {
|
||||
# BASS - Filtros, drive y compresion dinamica
|
||||
'bass': {
|
||||
'Saturator': {
|
||||
'Drive': {'intro': 1.5, 'build': 3.5, 'drop': 5.0, 'break': 2.0, 'outro': 1.8},
|
||||
'Dry/Wet': {'intro': 0.12, 'build': 0.22, 'drop': 0.30, 'break': 0.15, 'outro': 0.10},
|
||||
},
|
||||
'Auto Filter': {
|
||||
'Frequency': {'intro': 6200.0, 'build': 8500.0, 'drop': 12000.0, 'break': 4800.0, 'outro': 5800.0},
|
||||
'Dry/Wet': {'intro': 0.08, 'build': 0.18, 'drop': 0.12, 'break': 0.22, 'outro': 0.06},
|
||||
'Resonance': {'intro': 0.25, 'build': 0.35, 'drop': 0.20, 'break': 0.40, 'outro': 0.28},
|
||||
},
|
||||
'Compressor': {
|
||||
'Threshold': {'intro': -12.0, 'build': -14.0, 'drop': -18.0, 'break': -10.0, 'outro': -11.0},
|
||||
'Ratio': {'intro': 2.5, 'build': 3.0, 'drop': 4.0, 'break': 2.0, 'outro': 2.2},
|
||||
},
|
||||
'Utility': {
|
||||
'Stereo Width': {'intro': 0.0, 'build': 0.0, 'drop': 0.0, 'break': 0.0, 'outro': 0.0},
|
||||
},
|
||||
},
|
||||
'sub_bass': {
|
||||
'Saturator': {
|
||||
'Drive': {'intro': 1.0, 'build': 2.5, 'drop': 4.0, 'break': 1.5, 'outro': 1.2},
|
||||
},
|
||||
'Auto Filter': {
|
||||
'Frequency': {'intro': 5200.0, 'build': 7200.0, 'drop': 10000.0, 'break': 4200.0, 'outro': 4800.0},
|
||||
'Dry/Wet': {'intro': 0.05, 'build': 0.10, 'drop': 0.06, 'break': 0.14, 'outro': 0.04},
|
||||
},
|
||||
'Utility': {
|
||||
'Width': {'intro': 0.0, 'build': 0.0, 'drop': 0.0, 'break': 0.0, 'outro': 0.0},
|
||||
'Gain': {'intro': 0.0, 'build': 0.2, 'drop': 0.4, 'break': -0.2, 'outro': 0.0},
|
||||
},
|
||||
},
|
||||
# PAD - Filtros envolventes con width y reverb
|
||||
'pad': {
|
||||
'Auto Filter': {
|
||||
'Frequency': {'intro': 4500.0, 'build': 8000.0, 'drop': 11000.0, 'break': 3200.0, 'outro': 4000.0},
|
||||
'Dry/Wet': {'intro': 0.25, 'build': 0.18, 'drop': 0.12, 'break': 0.35, 'outro': 0.28},
|
||||
'Resonance': {'intro': 0.20, 'build': 0.28, 'drop': 0.15, 'break': 0.35, 'outro': 0.22},
|
||||
},
|
||||
'Hybrid Reverb': {
|
||||
'Dry/Wet': {'intro': 0.22, 'build': 0.16, 'drop': 0.10, 'break': 0.28, 'outro': 0.24},
|
||||
'Decay Time': {'intro': 3.5, 'build': 2.8, 'drop': 2.0, 'break': 4.2, 'outro': 3.8},
|
||||
},
|
||||
'Utility': {
|
||||
'Stereo Width': {'intro': 0.85, 'build': 1.02, 'drop': 1.12, 'break': 1.25, 'outro': 0.90},
|
||||
},
|
||||
'Saturator': {
|
||||
'Drive': {'intro': 0.8, 'build': 1.5, 'drop': 2.5, 'break': 0.6, 'outro': 0.7},
|
||||
'Dry/Wet': {'intro': 0.10, 'build': 0.15, 'drop': 0.20, 'break': 0.08, 'outro': 0.12},
|
||||
},
|
||||
},
|
||||
# ATMOS - Filtros espaciales con movement
|
||||
'atmos': {
|
||||
'Auto Filter': {
|
||||
'Frequency': {'intro': 3800.0, 'build': 7200.0, 'drop': 9800.0, 'break': 2800.0, 'outro': 3500.0},
|
||||
'Dry/Wet': {'intro': 0.30, 'build': 0.22, 'drop': 0.15, 'break': 0.40, 'outro': 0.32},
|
||||
'Resonance': {'intro': 0.22, 'build': 0.32, 'drop': 0.18, 'break': 0.42, 'outro': 0.25},
|
||||
},
|
||||
'Hybrid Reverb': {
|
||||
'Dry/Wet': {'intro': 0.35, 'build': 0.28, 'drop': 0.18, 'break': 0.42, 'outro': 0.38},
|
||||
'Decay Time': {'intro': 4.0, 'build': 3.2, 'drop': 2.2, 'break': 5.0, 'outro': 4.5},
|
||||
},
|
||||
'Utility': {
|
||||
'Stereo Width': {'intro': 0.70, 'build': 0.88, 'drop': 1.05, 'break': 1.20, 'outro': 0.75},
|
||||
},
|
||||
},
|
||||
# FX ELEMENTS
|
||||
'reverse_fx': {
|
||||
'Auto Filter': {
|
||||
'Frequency': {'intro': 5200.0, 'build': 9000.0, 'drop': 12000.0, 'break': 6000.0, 'outro': 4800.0},
|
||||
'Dry/Wet': {'intro': 0.20, 'build': 0.28, 'drop': 0.15, 'break': 0.35, 'outro': 0.22},
|
||||
},
|
||||
'Hybrid Reverb': {
|
||||
'Dry/Wet': {'intro': 0.30, 'build': 0.35, 'drop': 0.20, 'break': 0.40, 'outro': 0.28},
|
||||
'Decay Time': {'intro': 3.0, 'build': 4.5, 'drop': 2.5, 'break': 5.5, 'outro': 3.5},
|
||||
},
|
||||
'Saturator': {
|
||||
'Drive': {'intro': 1.2, 'build': 2.8, 'drop': 4.5, 'break': 1.8, 'outro': 1.0},
|
||||
},
|
||||
},
|
||||
'riser': {
|
||||
'Auto Filter': {
|
||||
'Frequency': {'intro': 4000.0, 'build': 10000.0, 'drop': 14000.0, 'break': 5500.0, 'outro': 4200.0},
|
||||
'Dry/Wet': {'intro': 0.15, 'build': 0.30, 'drop': 0.12, 'break': 0.22, 'outro': 0.18},
|
||||
},
|
||||
'Hybrid Reverb': {
|
||||
'Dry/Wet': {'intro': 0.25, 'build': 0.40, 'drop': 0.22, 'break': 0.35, 'outro': 0.20},
|
||||
'Decay Time': {'intro': 2.5, 'build': 5.0, 'drop': 3.0, 'break': 4.0, 'outro': 2.8},
|
||||
},
|
||||
'Echo': {
|
||||
'Dry/Wet': {'intro': 0.18, 'build': 0.35, 'drop': 0.15, 'break': 0.25, 'outro': 0.15},
|
||||
'Feedback': {'intro': 0.30, 'build': 0.55, 'drop': 0.25, 'break': 0.45, 'outro': 0.28},
|
||||
},
|
||||
'Saturator': {
|
||||
'Drive': {'intro': 1.5, 'build': 4.0, 'drop': 3.0, 'break': 2.5, 'outro': 1.2},
|
||||
},
|
||||
},
|
||||
'impact': {
|
||||
'Hybrid Reverb': {
|
||||
'Dry/Wet': {'intro': 0.15, 'build': 0.18, 'drop': 0.12, 'break': 0.20, 'outro': 0.14},
|
||||
'Decay Time': {'intro': 2.0, 'build': 2.5, 'drop': 1.8, 'break': 3.0, 'outro': 2.2},
|
||||
},
|
||||
'Saturator': {
|
||||
'Drive': {'intro': 1.8, 'build': 2.5, 'drop': 3.5, 'break': 2.0, 'outro': 1.5},
|
||||
},
|
||||
},
|
||||
'drone': {
|
||||
'Auto Filter': {
|
||||
'Frequency': {'intro': 3000.0, 'build': 6500.0, 'drop': 9000.0, 'break': 2500.0, 'outro': 2800.0},
|
||||
'Dry/Wet': {'intro': 0.20, 'build': 0.15, 'drop': 0.10, 'break': 0.30, 'outro': 0.22},
|
||||
'Resonance': {'intro': 0.25, 'build': 0.35, 'drop': 0.22, 'break': 0.40, 'outro': 0.28},
|
||||
},
|
||||
'Hybrid Reverb': {
|
||||
'Dry/Wet': {'intro': 0.18, 'build': 0.14, 'drop': 0.08, 'break': 0.25, 'outro': 0.20},
|
||||
'Decay Time': {'intro': 4.5, 'build': 3.5, 'drop': 2.5, 'break': 5.5, 'outro': 4.8},
|
||||
},
|
||||
'Saturator': {
|
||||
'Drive': {'intro': 0.8, 'build': 1.8, 'drop': 2.8, 'break': 0.6, 'outro': 0.7},
|
||||
},
|
||||
},
|
||||
# HATS - Filtros de brillantez con resonance y saturacion
|
||||
'hat_closed': {
|
||||
'Auto Filter': {
|
||||
'Frequency': {'intro': 12000.0, 'build': 14000.0, 'drop': 16000.0, 'break': 10000.0, 'outro': 11000.0},
|
||||
'Dry/Wet': {'intro': 0.12, 'build': 0.16, 'drop': 0.10, 'break': 0.20, 'outro': 0.14},
|
||||
'Resonance': {'intro': 0.15, 'build': 0.25, 'drop': 0.12, 'outro': 0.18, 'break': 0.30},
|
||||
},
|
||||
'Saturator': {
|
||||
'Drive': {'intro': 0.5, 'build': 1.2, 'drop': 1.8, 'break': 0.8, 'outro': 0.6},
|
||||
},
|
||||
},
|
||||
'hat_open': {
|
||||
'Auto Filter': {
|
||||
'Frequency': {'intro': 9000.0, 'build': 11000.0, 'drop': 13000.0, 'break': 7500.0, 'outro': 8500.0},
|
||||
'Dry/Wet': {'intro': 0.18, 'build': 0.22, 'drop': 0.14, 'break': 0.28, 'outro': 0.20},
|
||||
'Resonance': {'intro': 0.18, 'build': 0.28, 'drop': 0.15, 'outro': 0.20, 'break': 0.35},
|
||||
},
|
||||
'Echo': {
|
||||
'Dry/Wet': {'intro': 0.08, 'build': 0.15, 'drop': 0.10, 'break': 0.22, 'outro': 0.12},
|
||||
},
|
||||
},
|
||||
'top_loop': {
|
||||
'Auto Filter': {
|
||||
'Frequency': {'intro': 8500.0, 'build': 10500.0, 'drop': 12500.0, 'break': 7000.0, 'outro': 8000.0},
|
||||
'Dry/Wet': {'intro': 0.20, 'build': 0.25, 'drop': 0.16, 'break': 0.32, 'outro': 0.22},
|
||||
'Resonance': {'intro': 0.12, 'build': 0.22, 'drop': 0.14, 'outro': 0.15, 'break': 0.28},
|
||||
},
|
||||
'Echo': {
|
||||
'Dry/Wet': {'intro': 0.05, 'build': 0.12, 'drop': 0.08, 'break': 0.18, 'outro': 0.10},
|
||||
},
|
||||
},
|
||||
# SYNTHS
|
||||
'chords': {
|
||||
'Auto Filter': {
|
||||
'Frequency': {'intro': 5500.0, 'build': 8500.0, 'drop': 11000.0, 'break': 4000.0, 'outro': 5000.0},
|
||||
'Dry/Wet': {'intro': 0.15, 'build': 0.20, 'drop': 0.12, 'break': 0.28, 'outro': 0.18},
|
||||
'Resonance': {'intro': 0.18, 'build': 0.28, 'drop': 0.15, 'outro': 0.20, 'break': 0.35},
|
||||
},
|
||||
'Echo': {
|
||||
'Dry/Wet': {'intro': 0.10, 'build': 0.18, 'drop': 0.08, 'break': 0.22, 'outro': 0.12},
|
||||
'Feedback': {'intro': 0.25, 'build': 0.40, 'drop': 0.30, 'break': 0.45, 'outro': 0.28},
|
||||
},
|
||||
'Saturator': {
|
||||
'Drive': {'intro': 1.2, 'build': 2.2, 'drop': 3.5, 'break': 1.5, 'outro': 1.0},
|
||||
},
|
||||
'Utility': {
|
||||
'Stereo Width': {'intro': 0.95, 'build': 1.05, 'drop': 1.15, 'break': 1.25, 'outro': 1.00},
|
||||
},
|
||||
},
|
||||
'lead': {
|
||||
'Saturator': {
|
||||
'Drive': {'intro': 1.0, 'build': 2.5, 'drop': 4.0, 'break': 1.5, 'outro': 1.2},
|
||||
'Dry/Wet': {'intro': 0.12, 'build': 0.20, 'drop': 0.25, 'break': 0.10, 'outro': 0.15},
|
||||
},
|
||||
'Echo': {
|
||||
'Dry/Wet': {'intro': 0.08, 'build': 0.15, 'drop': 0.10, 'break': 0.18, 'outro': 0.10},
|
||||
'Feedback': {'intro': 0.20, 'build': 0.35, 'drop': 0.28, 'break': 0.40, 'outro': 0.22},
|
||||
},
|
||||
'Auto Filter': {
|
||||
'Frequency': {'intro': 6500.0, 'build': 9500.0, 'drop': 12500.0, 'break': 4500.0, 'outro': 5500.0},
|
||||
'Dry/Wet': {'intro': 0.08, 'build': 0.15, 'drop': 0.10, 'break': 0.20, 'outro': 0.12},
|
||||
},
|
||||
'Utility': {
|
||||
'Stereo Width': {'intro': 0.90, 'build': 1.02, 'drop': 1.10, 'break': 1.18, 'outro': 0.95},
|
||||
},
|
||||
},
|
||||
'stab': {
|
||||
'Saturator': {
|
||||
'Drive': {'intro': 2.0, 'build': 3.5, 'drop': 5.0, 'break': 2.5, 'outro': 2.2},
|
||||
'Dry/Wet': {'intro': 0.18, 'build': 0.25, 'drop': 0.30, 'break': 0.15, 'outro': 0.20},
|
||||
},
|
||||
'Auto Filter': {
|
||||
'Frequency': {'intro': 6000.0, 'build': 9000.0, 'drop': 12000.0, 'break': 5000.0, 'outro': 5500.0},
|
||||
'Dry/Wet': {'intro': 0.10, 'build': 0.15, 'drop': 0.08, 'break': 0.22, 'outro': 0.12},
|
||||
},
|
||||
'Utility': {
|
||||
'Stereo Width': {'intro': 0.88, 'build': 1.00, 'drop': 1.12, 'break': 1.20, 'outro': 0.92},
|
||||
},
|
||||
},
|
||||
'pluck': {
|
||||
'Echo': {
|
||||
'Dry/Wet': {'intro': 0.12, 'build': 0.22, 'drop': 0.14, 'break': 0.28, 'outro': 0.15},
|
||||
'Feedback': {'intro': 0.30, 'build': 0.45, 'drop': 0.35, 'break': 0.50, 'outro': 0.32},
|
||||
},
|
||||
'Auto Filter': {
|
||||
'Frequency': {'intro': 7000.0, 'build': 10000.0, 'drop': 13000.0, 'break': 5500.0, 'outro': 6500.0},
|
||||
'Dry/Wet': {'intro': 0.08, 'build': 0.15, 'drop': 0.10, 'break': 0.20, 'outro': 0.12},
|
||||
},
|
||||
'Saturator': {
|
||||
'Drive': {'intro': 0.8, 'build': 1.8, 'drop': 2.8, 'break': 1.2, 'outro': 0.9},
|
||||
},
|
||||
},
|
||||
'arp': {
|
||||
'Echo': {
|
||||
'Dry/Wet': {'intro': 0.15, 'build': 0.28, 'drop': 0.18, 'break': 0.35, 'outro': 0.18},
|
||||
'Feedback': {'intro': 0.35, 'build': 0.50, 'drop': 0.40, 'break': 0.58, 'outro': 0.38},
|
||||
},
|
||||
'Auto Filter': {
|
||||
'Frequency': {'intro': 6500.0, 'build': 9500.0, 'drop': 12500.0, 'break': 5000.0, 'outro': 6000.0},
|
||||
'Dry/Wet': {'intro': 0.12, 'build': 0.18, 'drop': 0.14, 'break': 0.25, 'outro': 0.15},
|
||||
},
|
||||
'Saturator': {
|
||||
'Drive': {'intro': 0.6, 'build': 1.5, 'drop': 2.5, 'break': 1.0, 'outro': 0.7},
|
||||
},
|
||||
},
|
||||
'counter': {
|
||||
'Echo': {
|
||||
'Dry/Wet': {'intro': 0.10, 'build': 0.18, 'drop': 0.12, 'break': 0.22, 'outro': 0.12},
|
||||
},
|
||||
'Auto Filter': {
|
||||
'Frequency': {'intro': 6000.0, 'build': 8800.0, 'drop': 11500.0, 'break': 4800.0, 'outro': 5200.0},
|
||||
'Dry/Wet': {'intro': 0.10, 'build': 0.16, 'drop': 0.12, 'break': 0.22, 'outro': 0.14},
|
||||
},
|
||||
'Utility': {
|
||||
'Stereo Width': {'intro': 0.75, 'build': 0.92, 'drop': 1.08, 'break': 1.15, 'outro': 0.80},
|
||||
},
|
||||
},
|
||||
# VOCAL
|
||||
'vocal': {
|
||||
'Echo': {
|
||||
'Dry/Wet': {'intro': 0.12, 'build': 0.25, 'drop': 0.15, 'break': 0.30, 'outro': 0.14},
|
||||
'Feedback': {'intro': 0.25, 'build': 0.42, 'drop': 0.30, 'break': 0.48, 'outro': 0.28},
|
||||
},
|
||||
'Hybrid Reverb': {
|
||||
'Dry/Wet': {'intro': 0.08, 'build': 0.15, 'drop': 0.06, 'break': 0.18, 'outro': 0.10},
|
||||
'Decay Time': {'intro': 2.5, 'build': 3.5, 'drop': 2.0, 'break': 4.0, 'outro': 2.8},
|
||||
},
|
||||
'Auto Filter': {
|
||||
'Frequency': {'intro': 6000.0, 'build': 9000.0, 'drop': 11000.0, 'break': 5000.0, 'outro': 5500.0},
|
||||
'Dry/Wet': {'intro': 0.10, 'build': 0.16, 'drop': 0.10, 'break': 0.20, 'outro': 0.12},
|
||||
},
|
||||
'Saturator': {
|
||||
'Drive': {'intro': 0.8, 'build': 1.8, 'drop': 2.5, 'break': 1.2, 'outro': 0.9},
|
||||
},
|
||||
},
|
||||
# DRUMS - Sin automatizacion de devices (manejados por volumen/sends)
|
||||
'kick': {},
|
||||
'clap': {},
|
||||
'snare_fill': {},
|
||||
'perc': {},
|
||||
'ride': {},
|
||||
'tom_fill': {},
|
||||
'crash': {},
|
||||
'sc_trigger': {},
|
||||
}
|
||||
|
||||
# =============================================================================
|
||||
# ENHANCED BUS DEVICE AUTOMATION - More drive/compression per section
|
||||
# =============================================================================
|
||||
|
||||
BUS_DEVICE_AUTOMATION = {
|
||||
'drums': {
|
||||
'Compressor': {
|
||||
'Threshold': {'intro': -14.0, 'build': -16.0, 'drop': -18.5, 'break': -12.0, 'outro': -13.5},
|
||||
'Ratio': {'intro': 2.5, 'build': 3.0, 'drop': 4.0, 'break': 2.2, 'outro': 2.4},
|
||||
'Attack': {'intro': 0.015, 'build': 0.010, 'drop': 0.005, 'break': 0.020, 'outro': 0.018},
|
||||
},
|
||||
'Saturator': {
|
||||
'Drive': {'intro': 0.8, 'build': 1.5, 'drop': 2.5, 'break': 1.0, 'outro': 0.9},
|
||||
'Dry/Wet': {'intro': 0.08, 'build': 0.15, 'drop': 0.22, 'break': 0.10, 'outro': 0.10},
|
||||
},
|
||||
'Limiter': {
|
||||
'Gain': {'intro': 0.2, 'build': 0.3, 'drop': 0.5, 'break': 0.15, 'outro': 0.18},
|
||||
},
|
||||
'Auto Filter': {
|
||||
'Frequency': {'intro': 8500.0, 'build': 10000.0, 'drop': 14000.0, 'break': 6500.0, 'outro': 7500.0},
|
||||
'Dry/Wet': {'intro': 0.12, 'build': 0.10, 'drop': 0.05, 'break': 0.18, 'outro': 0.14},
|
||||
},
|
||||
},
|
||||
'bass': {
|
||||
'Saturator': {
|
||||
'Drive': {'intro': 1.0, 'build': 2.0, 'drop': 3.5, 'break': 1.5, 'outro': 1.2},
|
||||
'Dry/Wet': {'intro': 0.10, 'build': 0.18, 'drop': 0.25, 'break': 0.12, 'outro': 0.10},
|
||||
},
|
||||
'Compressor': {
|
||||
'Threshold': {'intro': -15.0, 'build': -17.0, 'drop': -20.0, 'break': -14.0, 'outro': -14.5},
|
||||
'Ratio': {'intro': 3.0, 'build': 3.5, 'drop': 4.5, 'break': 2.8, 'outro': 3.0},
|
||||
'Attack': {'intro': 0.020, 'build': 0.015, 'drop': 0.008, 'break': 0.025, 'outro': 0.022},
|
||||
},
|
||||
'Utility': {
|
||||
'Stereo Width': {'intro': 0.0, 'build': 0.0, 'drop': 0.0, 'break': 0.0, 'outro': 0.0},
|
||||
},
|
||||
'Auto Filter': {
|
||||
'Frequency': {'intro': 5000.0, 'build': 7000.0, 'drop': 10000.0, 'break': 4500.0, 'outro': 5200.0},
|
||||
'Dry/Wet': {'intro': 0.05, 'build': 0.08, 'drop': 0.12, 'break': 0.10, 'outro': 0.06},
|
||||
},
|
||||
},
|
||||
'music': {
|
||||
'Compressor': {
|
||||
'Threshold': {'intro': -19.0, 'build': -20.0, 'drop': -22.0, 'break': -18.0, 'outro': -18.5},
|
||||
'Ratio': {'intro': 2.0, 'build': 2.5, 'drop': 3.0, 'break': 1.8, 'outro': 2.0},
|
||||
'Attack': {'intro': 0.025, 'build': 0.020, 'drop': 0.015, 'break': 0.030, 'outro': 0.028},
|
||||
},
|
||||
'Auto Filter': {
|
||||
'Frequency': {'intro': 8000.0, 'build': 11000.0, 'drop': 14000.0, 'break': 6000.0, 'outro': 7500.0},
|
||||
'Dry/Wet': {'intro': 0.08, 'build': 0.05, 'drop': 0.03, 'break': 0.12, 'outro': 0.10},
|
||||
},
|
||||
'Utility': {
|
||||
'Stereo Width': {'intro': 1.05, 'build': 1.10, 'drop': 1.12, 'break': 1.18, 'outro': 1.08},
|
||||
},
|
||||
'Saturator': {
|
||||
'Drive': {'intro': 0.3, 'build': 0.8, 'drop': 1.5, 'break': 0.4, 'outro': 0.35},
|
||||
'Dry/Wet': {'intro': 0.05, 'build': 0.10, 'drop': 0.15, 'break': 0.08, 'outro': 0.06},
|
||||
},
|
||||
},
|
||||
'vocal': {
|
||||
'Echo': {
|
||||
'Dry/Wet': {'intro': 0.06, 'build': 0.10, 'drop': 0.05, 'break': 0.15, 'outro': 0.08},
|
||||
'Feedback': {'intro': 0.25, 'build': 0.38, 'drop': 0.28, 'break': 0.45, 'outro': 0.30},
|
||||
},
|
||||
'Compressor': {
|
||||
'Threshold': {'intro': -16.0, 'build': -17.0, 'drop': -19.0, 'break': -15.0, 'outro': -15.5},
|
||||
'Ratio': {'intro': 2.8, 'build': 3.2, 'drop': 3.8, 'break': 2.5, 'outro': 2.7},
|
||||
},
|
||||
'Hybrid Reverb': {
|
||||
'Dry/Wet': {'intro': 0.04, 'build': 0.08, 'drop': 0.03, 'break': 0.12, 'outro': 0.06},
|
||||
'Decay Time': {'intro': 2.0, 'build': 2.8, 'drop': 1.5, 'break': 3.5, 'outro': 2.5},
|
||||
},
|
||||
'Auto Filter': {
|
||||
'Frequency': {'intro': 8500.0, 'build': 10500.0, 'drop': 13000.0, 'break': 7200.0, 'outro': 8000.0},
|
||||
'Dry/Wet': {'intro': 0.06, 'build': 0.10, 'drop': 0.04, 'break': 0.14, 'outro': 0.08},
|
||||
},
|
||||
},
|
||||
'fx': {
|
||||
'Auto Filter': {
|
||||
'Frequency': {'intro': 6500.0, 'build': 9500.0, 'drop': 12000.0, 'break': 5500.0, 'outro': 6000.0},
|
||||
'Dry/Wet': {'intro': 0.12, 'build': 0.10, 'drop': 0.06, 'break': 0.18, 'outro': 0.14},
|
||||
'Resonance': {'intro': 0.15, 'build': 0.22, 'drop': 0.12, 'break': 0.28, 'outro': 0.18},
|
||||
},
|
||||
'Hybrid Reverb': {
|
||||
'Dry/Wet': {'intro': 0.15, 'build': 0.18, 'drop': 0.10, 'break': 0.22, 'outro': 0.16},
|
||||
'Decay Time': {'intro': 2.5, 'build': 3.2, 'drop': 2.0, 'break': 4.0, 'outro': 3.0},
|
||||
},
|
||||
'Limiter': {
|
||||
'Gain': {'intro': -0.2, 'build': 0.0, 'drop': 0.2, 'break': -0.3, 'outro': -0.1},
|
||||
},
|
||||
'Saturator': {
|
||||
'Drive': {'intro': 0.5, 'build': 1.2, 'drop': 2.0, 'break': 0.8, 'outro': 0.6},
|
||||
'Dry/Wet': {'intro': 0.08, 'build': 0.12, 'drop': 0.18, 'break': 0.10, 'outro': 0.10},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
# =============================================================================
|
||||
# ENHANCED MASTER Device Automation - Section Energy Response
|
||||
# =============================================================================
|
||||
|
||||
MASTER_DEVICE_AUTOMATION = {
|
||||
'Utility': {
|
||||
'Stereo Width': {'intro': 1.04, 'build': 1.08, 'drop': 1.10, 'break': 1.12, 'outro': 1.06},
|
||||
'Gain': {'intro': 0.6, 'build': 0.8, 'drop': 1.0, 'break': 0.5, 'outro': 0.5},
|
||||
},
|
||||
'Saturator': {
|
||||
'Drive': {'intro': 0.2, 'build': 0.35, 'drop': 0.5, 'break': 0.15, 'outro': 0.18},
|
||||
'Dry/Wet': {'intro': 0.10, 'build': 0.18, 'drop': 0.25, 'break': 0.08, 'outro': 0.12},
|
||||
},
|
||||
'Compressor': {
|
||||
'Ratio': {'intro': 0.55, 'build': 0.62, 'drop': 0.70, 'break': 0.50, 'outro': 0.52},
|
||||
'Threshold': {'intro': -10.0, 'build': -12.0, 'drop': -14.0, 'break': -8.0, 'outro': -9.0},
|
||||
'Attack': {'intro': 0.020, 'build': 0.015, 'drop': 0.010, 'break': 0.025, 'outro': 0.022},
|
||||
'Release': {'intro': 0.15, 'build': 0.12, 'drop': 0.08, 'break': 0.18, 'outro': 0.16},
|
||||
},
|
||||
'Limiter': {
|
||||
'Gain': {'intro': 1.0, 'build': 1.2, 'drop': 1.4, 'break': 0.9, 'outro': 0.95},
|
||||
'Ceiling': {'intro': -0.5, 'build': -0.8, 'drop': -1.0, 'break': -0.3, 'outro': -0.4},
|
||||
},
|
||||
'Auto Filter': {
|
||||
'Frequency': {'intro': 8000.0, 'build': 11000.0, 'drop': 15000.0, 'break': 6000.0, 'outro': 7000.0},
|
||||
'Dry/Wet': {'intro': 0.05, 'build': 0.03, 'drop': 0.02, 'break': 0.08, 'outro': 0.06},
|
||||
},
|
||||
'Echo': {
|
||||
'Dry/Wet': {'intro': 0.02, 'build': 0.06, 'drop': 0.04, 'break': 0.08, 'outro': 0.04},
|
||||
'Feedback': {'intro': 0.15, 'build': 0.28, 'drop': 0.20, 'break': 0.32, 'outro': 0.22},
|
||||
},
|
||||
}
|
||||
|
||||
# Safety clamps for device parameters to prevent extreme values
|
||||
DEVICE_PARAMETER_SAFETY_CLAMPS = {
|
||||
'Drive': {'min': 0.0, 'max': 6.0},
|
||||
'Frequency': {'min': 20.0, 'max': 20000.0},
|
||||
'Dry/Wet': {'min': 0.0, 'max': 1.0},
|
||||
'Feedback': {'min': 0.0, 'max': 0.7},
|
||||
'Stereo Width': {'min': 0.0, 'max': 1.3},
|
||||
'Resonance': {'min': 0.0, 'max': 1.0},
|
||||
'Ratio': {'min': 1.0, 'max': 20.0},
|
||||
'Threshold': {'min': -60.0, 'max': 0.0},
|
||||
'Attack': {'min': 0.0001, 'max': 0.5},
|
||||
'Release': {'min': 0.001, 'max': 2.0},
|
||||
'Gain': {'min': -1.0, 'max': 1.8},
|
||||
'Decay Time': {'min': 0.1, 'max': 10.0},
|
||||
}
|
||||
|
||||
MASTER_SAFETY_CLAMPS = {
|
||||
'Stereo Width': {'min': 0.0, 'max': 1.25},
|
||||
'Drive': {'min': 0.0, 'max': 1.5},
|
||||
'Ratio': {'min': 0.45, 'max': 0.9},
|
||||
'Gain': {'min': 0.0, 'max': 1.6},
|
||||
'Attack': {'min': 0.0001, 'max': 0.1},
|
||||
'Ceiling': {'min': -3.0, 'max': 0.0},
|
||||
}
|
||||
192
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/full_integration.py
Normal file
192
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/full_integration.py
Normal file
@@ -0,0 +1,192 @@
|
||||
"""
|
||||
full_integration.py - Integración completa de todas las fases
|
||||
Este módulo conecta todos los nuevos engines con el flujo principal.
|
||||
"""
|
||||
import logging
|
||||
from typing import Dict, Any, List, Optional
|
||||
from pathlib import Path
|
||||
|
||||
# Imports de todos los nuevos módulos
|
||||
from human_feel import HumanFeelEngine
|
||||
from audio_soundscape import SoundscapeEngine, FXEngine, TonalAnalyzer
|
||||
from audio_arrangement import DJArrangementEngine, TransitionEngine
|
||||
from audio_mastering import MasterChain, LoudnessAnalyzer, QASuite, MasteringPreset
|
||||
from self_ai import AutoPrompter, CritiqueEngine, AutoFixEngine
|
||||
|
||||
logger = logging.getLogger("FullIntegration")
|
||||
|
||||
|
||||
class AbletonMCPFullPipeline:
|
||||
"""
|
||||
Pipeline completo que integra todas las fases:
|
||||
1. Auto-prompter (Fase 7)
|
||||
2. Palette selection (Fase 2)
|
||||
3. Arrangement generation (Fase 5)
|
||||
4. Human feel (Fase 3)
|
||||
5. Soundscape/FX (Fase 4)
|
||||
6. Mastering (Fase 6)
|
||||
7. QA validation (Fase 6)
|
||||
8. Critique & Auto-fix (Fase 7)
|
||||
"""
|
||||
|
||||
def __init__(self, seed: int = 42):
|
||||
self.seed = seed
|
||||
self.human_engine = HumanFeelEngine(seed=seed)
|
||||
self.soundscape_engine = SoundscapeEngine()
|
||||
self.fx_engine = FXEngine()
|
||||
self.tonal_analyzer = TonalAnalyzer()
|
||||
self.arrangement_engine = DJArrangementEngine(seed=seed)
|
||||
self.transition_engine = TransitionEngine()
|
||||
self.master_chain = MasterChain()
|
||||
self.loudness_analyzer = LoudnessAnalyzer()
|
||||
self.qa_suite = QASuite()
|
||||
self.auto_prompter = AutoPrompter()
|
||||
self.critique_engine = CritiqueEngine()
|
||||
self.auto_fix_engine = AutoFixEngine()
|
||||
|
||||
def generate_from_vibe(self, vibe_text: str, apply_full_pipeline: bool = True) -> Dict[str, Any]:
|
||||
"""
|
||||
Generación completa desde descripción de vibe.
|
||||
|
||||
Args:
|
||||
vibe_text: Descripción (ej: "dark warehouse techno")
|
||||
apply_full_pipeline: Si aplicar todas las fases
|
||||
|
||||
Returns:
|
||||
Dict con configuración completa del track
|
||||
"""
|
||||
logger.info(f"Starting generation from vibe: '{vibe_text}'")
|
||||
|
||||
# Fase 7: Auto-prompter
|
||||
params = self.auto_prompter.generate_from_vibe(vibe_text)
|
||||
logger.info(f"Detected: genre={params['genre']}, bpm={params['bpm']}, key={params['key']}")
|
||||
|
||||
# Preparar configuración
|
||||
config = {
|
||||
'vibe_params': params,
|
||||
'genre': params['genre'],
|
||||
'bpm': params['bpm'],
|
||||
'key': params['key'],
|
||||
'style': params['style'],
|
||||
'structure_type': params['structure'],
|
||||
'seed': self.seed,
|
||||
}
|
||||
|
||||
if apply_full_pipeline:
|
||||
config = self._apply_full_pipeline(config)
|
||||
|
||||
return config
|
||||
|
||||
def _apply_full_pipeline(self, config: Dict[str, Any]) -> Dict[str, Any]:
|
||||
"""Aplica todas las fases del pipeline."""
|
||||
|
||||
# Fase 5: Generar estructura
|
||||
structure = self.arrangement_engine.generate_structure(config.get('structure_type', 'standard'))
|
||||
config['structure'] = [
|
||||
{'name': s.name, 'kind': s.kind, 'bars': s.bars, 'energy': s.energy}
|
||||
for s in structure
|
||||
]
|
||||
config['dj_friendly'] = self.arrangement_engine.is_dj_friendly(structure)
|
||||
|
||||
# Fase 5: Transiciones
|
||||
transitions = self.transition_engine.generate_all_transitions(structure)
|
||||
config['transitions'] = transitions
|
||||
|
||||
# Fase 4: Soundscape gaps
|
||||
timeline = [{'start': 0, 'end': s.bars * 4, 'kind': s.kind} for s in structure]
|
||||
gaps = self.soundscape_engine.detect_ambience_gaps(timeline)
|
||||
atmos_events = self.soundscape_engine.fill_with_atmos(gaps, config['genre'], config['key'])
|
||||
config['atmos_events'] = atmos_events
|
||||
|
||||
# Fase 4: FX automáticos
|
||||
fx_events = []
|
||||
for section in structure:
|
||||
if section.kind == 'drop':
|
||||
riser = self.fx_engine.auto_riser_before_drop(section.bars * 4, 8)
|
||||
snare_roll = self.fx_engine.auto_snare_roll(section.bars * 4, 4)
|
||||
fx_events.extend([riser, snare_roll])
|
||||
config['fx_events'] = fx_events
|
||||
|
||||
# Fase 6: Master chain
|
||||
preset = MasteringPreset.get_preset('club' if 'techno' in config['genre'] else 'streaming')
|
||||
self.master_chain.set_limiter_ceiling(preset['ceiling'])
|
||||
config['master_chain'] = self.master_chain.get_ableton_device_chain()
|
||||
|
||||
# Fase 3: Configurar human feel
|
||||
config['human_feel'] = {
|
||||
'enabled': True,
|
||||
'timing_variation_ms': 5.0,
|
||||
'velocity_variance': 0.05,
|
||||
'note_skip_prob': 0.02,
|
||||
'groove_style': 'shuffle',
|
||||
'section_dynamics': True,
|
||||
}
|
||||
|
||||
return config
|
||||
|
||||
def critique_and_fix(self, song_data: Dict[str, Any]) -> Dict[str, Any]:
|
||||
"""
|
||||
Fase 7: Critique loop y auto-fix.
|
||||
|
||||
Args:
|
||||
song_data: Datos de la canción generada
|
||||
|
||||
Returns:
|
||||
Resultado con scores y fixes aplicados
|
||||
"""
|
||||
# Critique
|
||||
critique = self.critique_engine.critique_song(song_data)
|
||||
|
||||
# Auto-fix si hay weaknesses
|
||||
if critique['weaknesses']:
|
||||
fixes = self.auto_fix_engine.auto_fix(critique, song_data)
|
||||
return {
|
||||
'critique': critique,
|
||||
'fixes': fixes,
|
||||
'final_score': fixes['after_score']
|
||||
}
|
||||
|
||||
return {
|
||||
'critique': critique,
|
||||
'fixes': None,
|
||||
'final_score': critique['overall_score']
|
||||
}
|
||||
|
||||
def validate_master(self, audio_data: Any) -> Dict[str, Any]:
|
||||
"""
|
||||
Fase 6: Validación completa del master.
|
||||
|
||||
Args:
|
||||
audio_data: Datos de audio a validar
|
||||
|
||||
Returns:
|
||||
Reporte QA
|
||||
"""
|
||||
return self.qa_suite.run_full_qa(audio_data, {})
|
||||
|
||||
|
||||
# Instancia global
|
||||
_full_pipeline: Optional[AbletonMCPFullPipeline] = None
|
||||
|
||||
|
||||
def get_full_pipeline(seed: int = 42) -> AbletonMCPFullPipeline:
|
||||
"""Obtiene instancia del pipeline completo."""
|
||||
global _full_pipeline
|
||||
if _full_pipeline is None:
|
||||
_full_pipeline = AbletonMCPFullPipeline(seed=seed)
|
||||
return _full_pipeline
|
||||
|
||||
|
||||
def generate_complete_track(vibe_text: str, seed: int = 42) -> Dict[str, Any]:
|
||||
"""
|
||||
Función de conveniencia para generar un track completo.
|
||||
|
||||
Args:
|
||||
vibe_text: Descripción del vibe deseado
|
||||
seed: Seed para reproducibilidad
|
||||
|
||||
Returns:
|
||||
Configuración completa lista para AbletonMCP
|
||||
"""
|
||||
pipeline = get_full_pipeline(seed)
|
||||
return pipeline.generate_from_vibe(vibe_text, apply_full_pipeline=True)
|
||||
209
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/health_check.py
Normal file
209
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/health_check.py
Normal file
@@ -0,0 +1,209 @@
|
||||
"""
|
||||
health_check.py - Verificación de salud del sistema
|
||||
T107-T110: Health checks
|
||||
"""
|
||||
import sys
|
||||
import os
|
||||
import socket
|
||||
import json
|
||||
import logging
|
||||
from pathlib import Path
|
||||
from typing import Dict, Any, List
|
||||
|
||||
logging.basicConfig(level=logging.INFO)
|
||||
logger = logging.getLogger("HealthCheck")
|
||||
|
||||
|
||||
class AbletonMCPHealthCheck:
|
||||
"""Verifica la salud del sistema AbletonMCP-AI."""
|
||||
|
||||
def __init__(self):
|
||||
self.checks: List[Dict[str, Any]] = []
|
||||
self.all_passed = True
|
||||
|
||||
def check_ableton_connection(self) -> bool:
|
||||
"""Verifica conexión a Ableton Live."""
|
||||
try:
|
||||
# Intentar conectar al socket de Ableton
|
||||
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
||||
sock.settimeout(2)
|
||||
result = sock.connect_ex(('127.0.0.1', 9877))
|
||||
sock.close()
|
||||
|
||||
if result == 0:
|
||||
self._add_check("Ableton Connection", True, "Connected on port 9877")
|
||||
return True
|
||||
else:
|
||||
self._add_check("Ableton Connection", False, f"Port 9877 not available (code {result})")
|
||||
return False
|
||||
except Exception as e:
|
||||
self._add_check("Ableton Connection", False, str(e))
|
||||
return False
|
||||
|
||||
def check_mcp_server(self) -> bool:
|
||||
"""Verifica que el servidor MCP responde."""
|
||||
try:
|
||||
# Intentar importar el módulo
|
||||
from full_integration import AbletonMCPFullPipeline
|
||||
pipeline = AbletonMCPFullPipeline()
|
||||
|
||||
self._add_check("MCP Server", True, "Module imports successfully")
|
||||
return True
|
||||
except Exception as e:
|
||||
self._add_check("MCP Server", False, f"Import error: {e}")
|
||||
return False
|
||||
|
||||
def check_sample_library(self) -> bool:
|
||||
"""Verifica librería de samples."""
|
||||
lib_paths = [
|
||||
Path("librerias/organized_samples"), # Primary: organized with subfolders
|
||||
Path.home() / "embeddings" / "organized_samples",
|
||||
Path("librerias/all_tracks"), # Fallback: flat structure
|
||||
Path.home() / "embeddings" / "all_tracks",
|
||||
]
|
||||
|
||||
for path in lib_paths:
|
||||
if path.exists():
|
||||
wav_files = list(path.rglob("*.wav"))
|
||||
if len(wav_files) > 0:
|
||||
self._add_check("Sample Library", True, f"{len(wav_files)} samples at {path}")
|
||||
return True
|
||||
|
||||
self._add_check("Sample Library", False, "No sample library found")
|
||||
return False
|
||||
|
||||
def check_dependencies(self) -> bool:
|
||||
"""Verifica dependencias de Python."""
|
||||
required = [
|
||||
'numpy',
|
||||
'sklearn',
|
||||
'sentence_transformers',
|
||||
]
|
||||
|
||||
missing = []
|
||||
for dep in required:
|
||||
try:
|
||||
__import__(dep)
|
||||
except ImportError:
|
||||
missing.append(dep)
|
||||
|
||||
if missing:
|
||||
self._add_check("Dependencies", False, f"Missing: {', '.join(missing)}")
|
||||
return False
|
||||
|
||||
self._add_check("Dependencies", True, "All required packages available")
|
||||
return True
|
||||
|
||||
def check_vector_index(self) -> bool:
|
||||
"""Verifica índice de vectores."""
|
||||
index_paths = [
|
||||
Path("librerias/organized_samples/.sample_embeddings.json"), # Primary
|
||||
Path.home() / "embeddings" / "organized_samples" / ".sample_embeddings.json",
|
||||
Path("librerias/all_tracks/.sample_embeddings.json"), # Fallback
|
||||
Path.home() / "embeddings" / "all_tracks" / ".sample_embeddings.json",
|
||||
]
|
||||
|
||||
for path in index_paths:
|
||||
if path.exists():
|
||||
self._add_check("Vector Index", True, f"Index at {path}")
|
||||
return True
|
||||
|
||||
self._add_check("Vector Index", False, "No index found - will be built on first run")
|
||||
return False
|
||||
|
||||
def check_persistence_files(self) -> bool:
|
||||
"""Verifica archivos de persistencia."""
|
||||
data_dir = Path.home() / ".abletonmcp_ai"
|
||||
|
||||
files_to_check = [
|
||||
"sample_history.json",
|
||||
"sample_fatigue.json",
|
||||
"collection_coverage.json",
|
||||
]
|
||||
|
||||
all_ok = True
|
||||
for file in files_to_check:
|
||||
path = data_dir / file
|
||||
if path.exists():
|
||||
self._add_check(f"Persistence: {file}", True, "File exists")
|
||||
else:
|
||||
self._add_check(f"Persistence: {file}", False, "Will be created")
|
||||
all_ok = False
|
||||
|
||||
return all_ok
|
||||
|
||||
def check_tests(self) -> bool:
|
||||
"""Verifica que los tests pasan."""
|
||||
try:
|
||||
import subprocess
|
||||
result = subprocess.run(
|
||||
[sys.executable, "-m", "unittest", "tests.test_human_feel", "-v"],
|
||||
capture_output=True,
|
||||
timeout=30,
|
||||
cwd=Path(__file__).parent
|
||||
)
|
||||
|
||||
if result.returncode == 0:
|
||||
self._add_check("Unit Tests", True, "All tests passing")
|
||||
return True
|
||||
else:
|
||||
self._add_check("Unit Tests", False, "Some tests failed")
|
||||
return False
|
||||
except Exception as e:
|
||||
self._add_check("Unit Tests", False, f"Error running tests: {e}")
|
||||
return False
|
||||
|
||||
def _add_check(self, name: str, passed: bool, message: str):
|
||||
"""Agrega un check al reporte."""
|
||||
self.checks.append({
|
||||
'name': name,
|
||||
'passed': passed,
|
||||
'message': message
|
||||
})
|
||||
if not passed:
|
||||
self.all_passed = False
|
||||
|
||||
def run_all_checks(self) -> Dict[str, Any]:
|
||||
"""Ejecuta todos los checks."""
|
||||
logger.info("Running health checks...")
|
||||
logger.info("=" * 50)
|
||||
|
||||
self.check_ableton_connection()
|
||||
self.check_mcp_server()
|
||||
self.check_sample_library()
|
||||
self.check_dependencies()
|
||||
self.check_vector_index()
|
||||
self.check_persistence_files()
|
||||
self.check_tests()
|
||||
|
||||
# Summary
|
||||
passed = sum(1 for c in self.checks if c['passed'])
|
||||
total = len(self.checks)
|
||||
|
||||
logger.info("=" * 50)
|
||||
logger.info(f"RESULT: {passed}/{total} checks passed")
|
||||
|
||||
return {
|
||||
'all_passed': self.all_passed,
|
||||
'passed': passed,
|
||||
'total': total,
|
||||
'checks': self.checks
|
||||
}
|
||||
|
||||
|
||||
def main():
|
||||
"""Ejecuta health check desde línea de comandos."""
|
||||
checker = AbletonMCPHealthCheck()
|
||||
result = checker.run_all_checks()
|
||||
|
||||
# Guardar resultado
|
||||
output_path = Path("health_check_result.json")
|
||||
with open(output_path, 'w') as f:
|
||||
json.dump(result, f, indent=2)
|
||||
|
||||
# Exit code
|
||||
sys.exit(0 if result['all_passed'] else 1)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
103
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/human_feel.py
Normal file
103
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/human_feel.py
Normal file
@@ -0,0 +1,103 @@
|
||||
"""
|
||||
Human Feel Engine for AbletonMCP-AI
|
||||
T040-T050: Humanización y dinámicas
|
||||
"""
|
||||
import random
|
||||
from typing import List, Dict, Any
|
||||
|
||||
class HumanFeelEngine:
|
||||
"""
|
||||
T040-T050: Engine de humanización y dinámica.
|
||||
Aplica variaciones de timing, velocity y groove a patrones MIDI.
|
||||
"""
|
||||
|
||||
def __init__(self, seed: int = 42):
|
||||
self.rng = random.Random(seed)
|
||||
self._groove_templates = {
|
||||
'straight': {'swing': 0.0, 'humanize': 0.0},
|
||||
'shuffle': {'swing': 0.33, 'humanize': 0.02},
|
||||
'triplet': {'swing': 0.66, 'humanize': 0.03},
|
||||
'latin': {'swing': 0.25, 'humanize': 0.04},
|
||||
}
|
||||
|
||||
def apply_timing_variation(self, notes: List[Dict], amount_ms: float = 5.0) -> List[Dict]:
|
||||
"""T040: Micro-offsets de timing (-5ms a +5ms)."""
|
||||
result = []
|
||||
for note in notes:
|
||||
offset = self.rng.uniform(-amount_ms, amount_ms) / 1000.0
|
||||
new_note = dict(note)
|
||||
new_note['start'] = note.get('start', 0) + offset
|
||||
result.append(new_note)
|
||||
return result
|
||||
|
||||
def apply_velocity_humanize(self, notes: List[Dict], variance: float = 0.05) -> List[Dict]:
|
||||
"""T041: Humanización de velocity (±5% variación)."""
|
||||
result = []
|
||||
for note in notes:
|
||||
vel = note.get('velocity', 100)
|
||||
variation = self.rng.uniform(-variance, variance)
|
||||
new_vel = int(vel * (1 + variation))
|
||||
new_vel = max(1, min(127, new_vel))
|
||||
new_note = dict(note)
|
||||
new_note['velocity'] = new_vel
|
||||
result.append(new_note)
|
||||
return result
|
||||
|
||||
def apply_note_skip_probability(self, notes: List[Dict], prob: float = 0.02) -> List[Dict]:
|
||||
"""T042: Probabilidad de skip nota (2% ghost notes)."""
|
||||
result = []
|
||||
for note in notes:
|
||||
if self.rng.random() > prob:
|
||||
result.append(note)
|
||||
return result
|
||||
|
||||
def apply_groove(self, notes: List[Dict], style: str = 'shuffle', amount: float = 0.5) -> List[Dict]:
|
||||
"""T044-T046: Aplica groove template."""
|
||||
template = self._groove_templates.get(style, self._groove_templates['straight'])
|
||||
swing = template['swing'] * amount
|
||||
|
||||
result = []
|
||||
for note in notes:
|
||||
start = note.get('start', 0)
|
||||
beat_pos = start % 1.0
|
||||
if 0.4 < beat_pos < 0.6:
|
||||
delay = swing * 0.1
|
||||
new_note = dict(note)
|
||||
new_note['start'] = start + delay
|
||||
result.append(new_note)
|
||||
else:
|
||||
result.append(note)
|
||||
return result
|
||||
|
||||
def apply_section_dynamics(self, notes: List[Dict], section: str) -> List[Dict]:
|
||||
"""T047-T050: Dinámica por sección (intro 70%, drop 100%, etc)."""
|
||||
section_scales = {
|
||||
'intro': 0.70,
|
||||
'build': 0.85,
|
||||
'drop': 1.00,
|
||||
'break': 0.75,
|
||||
'outro': 0.60,
|
||||
}
|
||||
scale = section_scales.get(section.lower(), 1.0)
|
||||
|
||||
result = []
|
||||
for note in notes:
|
||||
vel = note.get('velocity', 100)
|
||||
new_vel = int(vel * scale)
|
||||
new_vel = max(1, min(127, new_vel))
|
||||
new_note = dict(note)
|
||||
new_note['velocity'] = new_vel
|
||||
result.append(new_note)
|
||||
return result
|
||||
|
||||
def process_notes(self, notes: List[Dict], section: str = 'drop',
|
||||
humanize: bool = True, groove_style: str = 'shuffle') -> List[Dict]:
|
||||
"""Procesamiento completo con todos los efectos."""
|
||||
result = list(notes)
|
||||
if humanize:
|
||||
result = self.apply_timing_variation(result)
|
||||
result = self.apply_velocity_humanize(result)
|
||||
result = self.apply_note_skip_probability(result)
|
||||
result = self.apply_groove(result, groove_style)
|
||||
result = self.apply_section_dynamics(result, section)
|
||||
return result
|
||||
@@ -0,0 +1,110 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
MCP Server 1429 - Servidor de prueba
|
||||
"""
|
||||
import json
|
||||
import sys
|
||||
|
||||
def log(msg):
|
||||
"""Log to stderr (stdout is used for MCP protocol)"""
|
||||
print(f"[1429] {msg}", file=sys.stderr, flush=True)
|
||||
|
||||
def send_response(response):
|
||||
"""Send JSON-RPC response to stdout"""
|
||||
json_str = json.dumps(response)
|
||||
print(json_str, flush=True)
|
||||
|
||||
def main():
|
||||
log("MCP Server 1429 iniciado")
|
||||
|
||||
for line in sys.stdin:
|
||||
line = line.strip()
|
||||
if not line:
|
||||
continue
|
||||
|
||||
try:
|
||||
request = json.loads(line)
|
||||
method = request.get("method", "")
|
||||
request_id = request.get("id")
|
||||
|
||||
log(f"Request: {method}")
|
||||
|
||||
# Handle initialize
|
||||
if method == "initialize":
|
||||
response = {
|
||||
"jsonrpc": "2.0",
|
||||
"id": request_id,
|
||||
"result": {
|
||||
"protocolVersion": "2024-11-05",
|
||||
"capabilities": {
|
||||
"tools": {}
|
||||
},
|
||||
"serverInfo": {
|
||||
"name": "1429",
|
||||
"version": "1.0.0"
|
||||
}
|
||||
}
|
||||
}
|
||||
send_response(response)
|
||||
|
||||
# Handle initialized notification
|
||||
elif method == "notifications/initialized":
|
||||
log("Client initialized")
|
||||
|
||||
# Handle tools/list
|
||||
elif method == "tools/list":
|
||||
response = {
|
||||
"jsonrpc": "2.0",
|
||||
"id": request_id,
|
||||
"result": {
|
||||
"tools": [
|
||||
{
|
||||
"name": "hola",
|
||||
"description": "Saluda y confirma que el MCP esta funcionando",
|
||||
"inputSchema": {
|
||||
"type": "object",
|
||||
"properties": {},
|
||||
"required": []
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
send_response(response)
|
||||
|
||||
# Handle tools/call
|
||||
elif method == "tools/call":
|
||||
response = {
|
||||
"jsonrpc": "2.0",
|
||||
"id": request_id,
|
||||
"result": {
|
||||
"content": [
|
||||
{
|
||||
"type": "text",
|
||||
"text": "hola! mcp funcionando"
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
send_response(response)
|
||||
|
||||
else:
|
||||
# Unknown method
|
||||
if request_id:
|
||||
response = {
|
||||
"jsonrpc": "2.0",
|
||||
"id": request_id,
|
||||
"error": {
|
||||
"code": -32601,
|
||||
"message": f"Method not found: {method}"
|
||||
}
|
||||
}
|
||||
send_response(response)
|
||||
|
||||
except json.JSONDecodeError as e:
|
||||
log(f"JSON error: {e}")
|
||||
except Exception as e:
|
||||
log(f"Error: {e}")
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
File diff suppressed because it is too large
Load Diff
485
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/pack_brain.py
Normal file
485
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/pack_brain.py
Normal file
@@ -0,0 +1,485 @@
|
||||
"""
|
||||
pack_brain.py - Palette/pack selection focused on coherent reggaeton production.
|
||||
|
||||
Builds candidate palettes from the local library by scoring folder-level coherence
|
||||
across drums, bass, music, vocal and FX material. The goal is to stop selecting
|
||||
good isolated samples that do not belong to the same sonic universe.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import itertools
|
||||
import logging
|
||||
import re
|
||||
from collections import Counter, defaultdict
|
||||
from dataclasses import dataclass, field
|
||||
from pathlib import Path
|
||||
from typing import Any, Dict, Iterable, List, Optional, Sequence, Tuple
|
||||
|
||||
logger = logging.getLogger("PackBrain")
|
||||
|
||||
IGNORED_SEGMENTS = {
|
||||
"(extra)",
|
||||
".sample_cache",
|
||||
".segment_rag",
|
||||
"__pycache__",
|
||||
"documentation",
|
||||
"installer",
|
||||
"flp",
|
||||
}
|
||||
|
||||
GENERIC_FOLDER_HINTS = {
|
||||
"kick",
|
||||
"snare",
|
||||
"drumloops",
|
||||
"drumloop",
|
||||
"oneshots",
|
||||
"one shots",
|
||||
"fx",
|
||||
"bass",
|
||||
"perc loop",
|
||||
"perc",
|
||||
"sounds presets",
|
||||
"sample pack",
|
||||
"drum loops",
|
||||
"instrumental loops",
|
||||
"vocal phrases",
|
||||
"music loops",
|
||||
"one shots",
|
||||
"hi hat",
|
||||
"hi-hat",
|
||||
}
|
||||
|
||||
BUS_ROLE_KEYWORDS = {
|
||||
"drums": {
|
||||
"kick", "snare", "clap", "hat", "hihat", "drum", "dembow", "perc",
|
||||
"percussion", "shaker", "loop", "drumloop", "toploop", "ride",
|
||||
},
|
||||
"bass": {"bass", "sub", "808", "reese"},
|
||||
"music": {
|
||||
"music", "instrumental", "synth", "lead", "pluck", "arp", "pad",
|
||||
"melody", "melodic", "keys", "piano", "guitar", "loop", "hook",
|
||||
},
|
||||
"vocal": {"vocal", "vox", "phrase", "double", "harmony", "libs", "choir"},
|
||||
"fx": {"fx", "impact", "riser", "fill", "sweep", "transition", "reverse", "atmos"},
|
||||
}
|
||||
|
||||
ROLE_TO_BUS = {
|
||||
"kick": "drums",
|
||||
"snare": "drums",
|
||||
"clap": "drums",
|
||||
"hat": "drums",
|
||||
"perc": "drums",
|
||||
"top_loop": "drums",
|
||||
"perc_loop": "drums",
|
||||
"bass": "bass",
|
||||
"sub": "bass",
|
||||
"bass_loop": "bass",
|
||||
"synth": "music",
|
||||
"synth_loop": "music",
|
||||
"synth_peak": "music",
|
||||
"instrumental": "music",
|
||||
"vocal": "vocal",
|
||||
"vocal_loop": "vocal",
|
||||
"vocal_peak": "vocal",
|
||||
"vocal_build": "vocal",
|
||||
"vocal_shot": "vocal",
|
||||
"fx": "fx",
|
||||
"fill_fx": "fx",
|
||||
"crash_fx": "fx",
|
||||
"atmos_fx": "fx",
|
||||
"snare_roll": "fx",
|
||||
}
|
||||
|
||||
STOP_TOKENS = {
|
||||
"wav", "mp3", "flac", "aiff", "aif", "loop", "loops", "shot", "shots", "one",
|
||||
"audio", "pack", "sample", "samples", "prod", "the", "and", "with", "para",
|
||||
"todos", "usan", "este", "type", "main", "latin", "latinos",
|
||||
}
|
||||
|
||||
|
||||
def _tokenize(text: str) -> List[str]:
|
||||
cleaned = re.sub(r"[^a-z0-9#]+", " ", str(text or "").lower())
|
||||
return [token for token in cleaned.split() if len(token) > 1 and token not in STOP_TOKENS]
|
||||
|
||||
|
||||
def _extract_bpm(text: str) -> Optional[float]:
|
||||
match = re.search(r"(?<!\d)(\d{2,3})(?:\s?bpm|\s?bpms)?(?!\d)", str(text or "").lower())
|
||||
if not match:
|
||||
return None
|
||||
value = float(match.group(1))
|
||||
if 60.0 <= value <= 180.0:
|
||||
return value
|
||||
return None
|
||||
|
||||
|
||||
def _normalize_key(value: Any) -> str:
|
||||
text = str(value or "").strip().lower()
|
||||
if not text:
|
||||
return ""
|
||||
text = text.replace("minor", "m").replace(" major", "").replace("maj", "")
|
||||
text = text.replace(" min", "m").replace("_", "").replace("-", "")
|
||||
if len(text) >= 2 and text[-1] == "m":
|
||||
return text[:-1] + "m"
|
||||
return text
|
||||
|
||||
|
||||
def _extract_key(text: str) -> str:
|
||||
lowered = str(text or "").lower()
|
||||
patterns = [
|
||||
r"([a-g])([#b]?)[ _-]?(?:min|minor|m)\b",
|
||||
r"([a-g])([#b]?)[ _-]?(?:maj|major)\b",
|
||||
r"\b([a-g])([#b]?m)\b",
|
||||
r"\b([a-g])([#b]?)\b",
|
||||
]
|
||||
for pattern in patterns:
|
||||
match = re.search(pattern, lowered)
|
||||
if not match:
|
||||
continue
|
||||
if len(match.groups()) == 2:
|
||||
return _normalize_key("".join(match.groups()))
|
||||
return _normalize_key("".join(match.groups()))
|
||||
return ""
|
||||
|
||||
|
||||
def _key_score(target_key: str, candidate_key: str) -> float:
|
||||
target = _normalize_key(target_key)
|
||||
candidate = _normalize_key(candidate_key)
|
||||
if not target or not candidate:
|
||||
return 0.55
|
||||
if target == candidate:
|
||||
return 1.0
|
||||
if target.rstrip("m") == candidate.rstrip("m"):
|
||||
return 0.82
|
||||
if target.endswith("m") == candidate.endswith("m"):
|
||||
return 0.68
|
||||
return 0.45
|
||||
|
||||
|
||||
def _shared_token_bonus(groups: Sequence[Sequence[str]]) -> Tuple[float, List[str]]:
|
||||
counters = [Counter(tokens) for tokens in groups if tokens]
|
||||
if not counters:
|
||||
return 0.0, []
|
||||
intersection = set(counters[0].keys())
|
||||
for counter in counters[1:]:
|
||||
intersection &= set(counter.keys())
|
||||
shared = sorted(token for token in intersection if token not in STOP_TOKENS)
|
||||
bonus = min(2.4, 0.35 * len(shared))
|
||||
return bonus, shared[:8]
|
||||
|
||||
|
||||
@dataclass
|
||||
class FolderStats:
|
||||
path: str
|
||||
bus: str
|
||||
sample_count: int = 0
|
||||
loop_count: int = 0
|
||||
one_shot_count: int = 0
|
||||
bpm_values: List[float] = field(default_factory=list)
|
||||
keys: Counter = field(default_factory=Counter)
|
||||
tokens: Counter = field(default_factory=Counter)
|
||||
source_roots: Counter = field(default_factory=Counter)
|
||||
|
||||
def to_summary(self) -> Dict[str, Any]:
|
||||
dominant_key = self.keys.most_common(1)[0][0] if self.keys else ""
|
||||
avg_bpm = round(sum(self.bpm_values) / len(self.bpm_values), 2) if self.bpm_values else None
|
||||
return {
|
||||
"path": self.path,
|
||||
"bus": self.bus,
|
||||
"sample_count": self.sample_count,
|
||||
"loop_count": self.loop_count,
|
||||
"one_shot_count": self.one_shot_count,
|
||||
"avg_bpm": avg_bpm,
|
||||
"dominant_key": dominant_key,
|
||||
"top_tokens": [token for token, _ in self.tokens.most_common(8)],
|
||||
"source_root": self.source_roots.most_common(1)[0][0] if self.source_roots else "",
|
||||
}
|
||||
|
||||
|
||||
class PackBrain:
|
||||
"""Derive coherent palettes from the user's library."""
|
||||
|
||||
def __init__(self, manager: Any):
|
||||
self.manager = manager
|
||||
self.base_dir = Path(getattr(manager, "base_dir", "."))
|
||||
self._folder_stats: Dict[Tuple[str, str], FolderStats] = {}
|
||||
self._prepared = False
|
||||
|
||||
def _should_ignore(self, sample_path: Path) -> bool:
|
||||
return any(part.strip().lower() in IGNORED_SEGMENTS for part in sample_path.parts)
|
||||
|
||||
def _detect_bus(self, sample: Any, sample_path: Path) -> str:
|
||||
haystack = " ".join(
|
||||
[
|
||||
sample_path.as_posix().lower(),
|
||||
str(getattr(sample, "category", "")).lower(),
|
||||
str(getattr(sample, "subcategory", "")).lower(),
|
||||
str(getattr(sample, "sample_type", "")).lower(),
|
||||
]
|
||||
)
|
||||
bus_scores = {}
|
||||
for bus, keywords in BUS_ROLE_KEYWORDS.items():
|
||||
bus_scores[bus] = sum(1 for keyword in keywords if keyword in haystack)
|
||||
if "vocal" in haystack or "vox" in haystack:
|
||||
bus_scores["vocal"] += 2
|
||||
if "fx" in haystack or "impact" in haystack or "transition" in haystack:
|
||||
bus_scores["fx"] += 2
|
||||
best_bus, best_score = max(bus_scores.items(), key=lambda item: item[1])
|
||||
return best_bus if best_score > 0 else "music"
|
||||
|
||||
def _source_root(self, relative_parts: Sequence[str]) -> str:
|
||||
for part in relative_parts:
|
||||
lowered = part.strip().lower()
|
||||
if lowered not in GENERIC_FOLDER_HINTS and lowered not in STOP_TOKENS:
|
||||
return part
|
||||
return relative_parts[0] if relative_parts else "library"
|
||||
|
||||
def _build_stats(self) -> None:
|
||||
if self._prepared:
|
||||
return
|
||||
|
||||
for sample in getattr(self.manager, "samples", {}).values():
|
||||
sample_path = Path(str(getattr(sample, "path", "") or ""))
|
||||
if not sample_path.is_file() or self._should_ignore(sample_path):
|
||||
continue
|
||||
try:
|
||||
rel = sample_path.relative_to(self.base_dir)
|
||||
rel_parts = rel.parts[:-1]
|
||||
except ValueError:
|
||||
rel_parts = sample_path.parts[:-1]
|
||||
bus = self._detect_bus(sample, sample_path)
|
||||
folder_key = (bus, str(sample_path.parent))
|
||||
stats = self._folder_stats.setdefault(folder_key, FolderStats(path=str(sample_path.parent), bus=bus))
|
||||
stats.sample_count += 1
|
||||
|
||||
sample_name = str(getattr(sample, "name", sample_path.stem))
|
||||
duration = float(getattr(sample, "duration", 0.0) or 0.0)
|
||||
bpm = getattr(sample, "bpm", None) or _extract_bpm(sample_name) or _extract_bpm(sample_path.as_posix())
|
||||
key = getattr(sample, "key", None) or _extract_key(sample_name) or _extract_key(sample_path.as_posix())
|
||||
if bpm:
|
||||
stats.bpm_values.append(float(bpm))
|
||||
if key:
|
||||
stats.keys[_normalize_key(key)] += 1
|
||||
|
||||
looks_like_loop = duration >= 1.25 or "loop" in sample_name.lower() or "loop" in sample_path.as_posix().lower()
|
||||
if looks_like_loop:
|
||||
stats.loop_count += 1
|
||||
else:
|
||||
stats.one_shot_count += 1
|
||||
|
||||
token_source = " ".join(list(rel_parts) + [sample_name])
|
||||
stats.tokens.update(_tokenize(token_source))
|
||||
stats.source_roots[self._source_root(rel_parts)] += 1
|
||||
|
||||
self._prepared = True
|
||||
|
||||
def _folder_request_score(self, stats: FolderStats, genre: str, style: str, bpm: float, key: str) -> Tuple[float, List[str]]:
|
||||
score = 0.0
|
||||
reasons: List[str] = []
|
||||
tokens = {token for token, _ in stats.tokens.most_common(20)}
|
||||
request_tokens = set(_tokenize(f"{genre} {style}"))
|
||||
folder_text = Path(stats.path).as_posix().lower()
|
||||
|
||||
if stats.sample_count:
|
||||
density_bonus = min(2.2, 0.2 * stats.sample_count)
|
||||
score += density_bonus
|
||||
reasons.append(f"{stats.sample_count} samples")
|
||||
|
||||
if stats.loop_count and stats.bus in {"drums", "music", "vocal"}:
|
||||
loop_bonus = min(1.6, 0.25 * stats.loop_count)
|
||||
score += loop_bonus
|
||||
if stats.one_shot_count and stats.bus in {"drums", "bass"}:
|
||||
one_shot_bonus = min(1.2, 0.2 * stats.one_shot_count)
|
||||
score += one_shot_bonus
|
||||
|
||||
if request_tokens:
|
||||
overlap = request_tokens & tokens
|
||||
if overlap:
|
||||
score += 0.6 * len(overlap)
|
||||
reasons.append(f"keywords {sorted(overlap)}")
|
||||
|
||||
if "reggaeton" in " ".join(tokens) or "dembow" in " ".join(tokens):
|
||||
score += 1.1
|
||||
|
||||
if stats.bus == "drums":
|
||||
if any(term in folder_text for term in ["/drum", "/kick", "/snare", "/oneshot", "drum loops", "drumloops"]):
|
||||
score += 1.4
|
||||
if "/fx/" in folder_text or "fill" in folder_text:
|
||||
score -= 0.9
|
||||
elif stats.bus == "bass":
|
||||
if "/bass/" in folder_text or " sub" in folder_text or "/sub" in folder_text:
|
||||
score += 1.6
|
||||
if "/fx/" in folder_text or "fill" in folder_text or "impact" in folder_text:
|
||||
score -= 1.8
|
||||
elif stats.bus == "music":
|
||||
if "instrumental loops" in folder_text or "music loops" in folder_text or "sample pack" in folder_text:
|
||||
score += 1.6
|
||||
if "/fx/" in folder_text or "fill" in folder_text or "drum loop" in folder_text:
|
||||
score -= 1.4
|
||||
elif stats.bus == "vocal":
|
||||
if "vocal" in folder_text or "vox" in folder_text or "phrases" in folder_text:
|
||||
score += 1.4
|
||||
elif stats.bus == "fx":
|
||||
if "/fx/" in folder_text or "fill" in folder_text or "impact" in folder_text or "transition" in folder_text:
|
||||
score += 1.4
|
||||
|
||||
if bpm > 0 and stats.bpm_values:
|
||||
avg_bpm = sum(stats.bpm_values) / len(stats.bpm_values)
|
||||
diff = abs(avg_bpm - bpm)
|
||||
if diff <= 1.5:
|
||||
score += 2.4
|
||||
reasons.append(f"BPM {avg_bpm:.1f}")
|
||||
elif diff <= 4:
|
||||
score += 1.8
|
||||
elif diff <= 8:
|
||||
score += 1.0
|
||||
elif abs(avg_bpm - (bpm * 2.0)) <= 4 or abs(avg_bpm - (bpm / 2.0)) <= 3:
|
||||
score += 0.75
|
||||
|
||||
if key and stats.keys:
|
||||
dominant_key = stats.keys.most_common(1)[0][0]
|
||||
compatibility = _key_score(key, dominant_key)
|
||||
score += compatibility * 2.2
|
||||
if compatibility >= 0.8:
|
||||
reasons.append(f"key {dominant_key}")
|
||||
|
||||
source_root = stats.source_roots.most_common(1)[0][0] if stats.source_roots else ""
|
||||
if source_root and source_root.lower() not in GENERIC_FOLDER_HINTS:
|
||||
score += 0.5
|
||||
|
||||
return score, reasons
|
||||
|
||||
def _support_folder_score(
|
||||
self,
|
||||
stats: FolderStats,
|
||||
requested_bus: str,
|
||||
palette_tokens: Sequence[Sequence[str]],
|
||||
genre: str,
|
||||
style: str,
|
||||
bpm: float,
|
||||
key: str,
|
||||
) -> float:
|
||||
base_score, _ = self._folder_request_score(stats, genre, style, bpm, key)
|
||||
bus_bonus = 1.2 if stats.bus == requested_bus else 0.0
|
||||
shared_bonus, _ = _shared_token_bonus(list(palette_tokens) + [[token for token, _ in stats.tokens.most_common(10)]])
|
||||
return base_score + bus_bonus + shared_bonus
|
||||
|
||||
def rank_palettes(
|
||||
self,
|
||||
genre: str,
|
||||
style: str = "",
|
||||
bpm: float = 0.0,
|
||||
key: str = "",
|
||||
max_candidates: int = 5,
|
||||
) -> Dict[str, Any]:
|
||||
self._build_stats()
|
||||
|
||||
bus_rankings: Dict[str, List[Tuple[float, FolderStats, List[str]]]] = defaultdict(list)
|
||||
for (_, _), stats in self._folder_stats.items():
|
||||
if stats.bus not in {"drums", "bass", "music", "vocal", "fx"}:
|
||||
continue
|
||||
folder_score, reasons = self._folder_request_score(stats, genre, style, bpm, key)
|
||||
if folder_score <= 0:
|
||||
continue
|
||||
bus_rankings[stats.bus].append((folder_score, stats, reasons))
|
||||
|
||||
for bus in bus_rankings:
|
||||
bus_rankings[bus].sort(key=lambda item: item[0], reverse=True)
|
||||
|
||||
drums = bus_rankings.get("drums", [])[:4]
|
||||
bass = bus_rankings.get("bass", [])[:4]
|
||||
music = bus_rankings.get("music", [])[:4]
|
||||
vocals = bus_rankings.get("vocal", [])[:4]
|
||||
fxs = bus_rankings.get("fx", [])[:4]
|
||||
|
||||
palette_candidates: List[Dict[str, Any]] = []
|
||||
candidate_index = 0
|
||||
|
||||
for drums_item, bass_item, music_item in itertools.product(drums or [None], bass or [None], music or [None]):
|
||||
if not drums_item or not bass_item or not music_item:
|
||||
continue
|
||||
selected = [drums_item[1], bass_item[1], music_item[1]]
|
||||
token_groups = [[token for token, _ in stats.tokens.most_common(10)] for stats in selected]
|
||||
shared_bonus, shared_tokens = _shared_token_bonus(token_groups)
|
||||
source_roots = [
|
||||
stats.source_roots.most_common(1)[0][0]
|
||||
for stats in selected
|
||||
if stats.source_roots
|
||||
]
|
||||
source_counter = Counter(source_roots)
|
||||
source_bonus = 0.0
|
||||
if source_counter:
|
||||
most_common_source, source_hits = source_counter.most_common(1)[0]
|
||||
if source_hits >= 3:
|
||||
source_bonus += 2.2
|
||||
elif source_hits == 2:
|
||||
source_bonus += 1.4
|
||||
if most_common_source.lower() in {"reggaeton 3", "sentimientolatino2025"}:
|
||||
source_bonus += 0.4
|
||||
if Path(bass_item[1].path).parent == Path(music_item[1].path).parent:
|
||||
source_bonus += 1.6
|
||||
|
||||
palette_score = drums_item[0] + bass_item[0] + music_item[0] + shared_bonus + source_bonus
|
||||
reason_bits = list(dict.fromkeys(drums_item[2] + bass_item[2] + music_item[2]))
|
||||
|
||||
palette = {
|
||||
"drums": drums_item[1].path,
|
||||
"bass": bass_item[1].path,
|
||||
"music": music_item[1].path,
|
||||
}
|
||||
|
||||
support_folders: Dict[str, str] = {}
|
||||
for bus_name, support_rankings in (("vocal", vocals), ("fx", fxs)):
|
||||
if not support_rankings:
|
||||
continue
|
||||
best_support = max(
|
||||
support_rankings,
|
||||
key=lambda item: self._support_folder_score(
|
||||
item[1], bus_name, token_groups, genre, style, bpm, key
|
||||
),
|
||||
)
|
||||
support_folders[bus_name] = best_support[1].path
|
||||
|
||||
if support_folders:
|
||||
palette_score += 0.35 * len(support_folders)
|
||||
|
||||
candidate_index += 1
|
||||
palette_candidates.append(
|
||||
{
|
||||
"id": f"palette-{candidate_index}",
|
||||
"score": round(palette_score, 3),
|
||||
"palette": palette,
|
||||
"support_folders": support_folders,
|
||||
"shared_tokens": shared_tokens,
|
||||
"reasons": reason_bits[:10],
|
||||
"folders": {
|
||||
"drums": drums_item[1].to_summary(),
|
||||
"bass": bass_item[1].to_summary(),
|
||||
"music": music_item[1].to_summary(),
|
||||
"vocal": next((item[1].to_summary() for item in vocals if item[1].path == support_folders.get("vocal")), None),
|
||||
"fx": next((item[1].to_summary() for item in fxs if item[1].path == support_folders.get("fx")), None),
|
||||
},
|
||||
}
|
||||
)
|
||||
|
||||
palette_candidates.sort(key=lambda item: item["score"], reverse=True)
|
||||
selected = palette_candidates[0] if palette_candidates else {}
|
||||
return {
|
||||
"genre": genre,
|
||||
"style": style,
|
||||
"bpm": bpm,
|
||||
"key": key,
|
||||
"selected_palette": selected,
|
||||
"candidates": palette_candidates[:max_candidates],
|
||||
"folder_rankings": {
|
||||
bus: [
|
||||
{
|
||||
"score": round(score, 3),
|
||||
"summary": stats.to_summary(),
|
||||
"reasons": reasons[:6],
|
||||
}
|
||||
for score, stats, reasons in rankings[:max_candidates]
|
||||
]
|
||||
for bus, rankings in bus_rankings.items()
|
||||
},
|
||||
}
|
||||
6
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/pytest.ini
Normal file
6
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/pytest.ini
Normal file
@@ -0,0 +1,6 @@
|
||||
[pytest]
|
||||
testpaths = tests
|
||||
python_files = test_*.py
|
||||
python_classes = Test*
|
||||
python_functions = test_*
|
||||
addopts = -v --tb=short
|
||||
4774
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/reference_listener.py
Normal file
4774
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/reference_listener.py
Normal file
File diff suppressed because it is too large
Load Diff
264
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/reference_stem_builder.py
Normal file
264
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/reference_stem_builder.py
Normal file
@@ -0,0 +1,264 @@
|
||||
"""
|
||||
reference_stem_builder.py - Rebuild an Ableton arrangement directly from a reference track.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import logging
|
||||
import socket
|
||||
from pathlib import Path
|
||||
from typing import Any, Dict, List, Tuple
|
||||
|
||||
import soundfile as sf
|
||||
import torch
|
||||
from demucs.apply import apply_model
|
||||
from demucs.pretrained import get_model
|
||||
|
||||
try:
|
||||
import librosa
|
||||
except ImportError: # pragma: no cover
|
||||
librosa = None
|
||||
|
||||
try:
|
||||
from reference_listener import ReferenceAudioListener
|
||||
except ImportError: # pragma: no cover
|
||||
from .reference_listener import ReferenceAudioListener
|
||||
|
||||
|
||||
logger = logging.getLogger("ReferenceStemBuilder")
|
||||
|
||||
HOST = "127.0.0.1"
|
||||
PORT = 9877
|
||||
MESSAGE_TERMINATOR = b"\n"
|
||||
SCRIPT_DIR = Path(__file__).resolve().parent
|
||||
PACKAGE_DIR = SCRIPT_DIR.parent
|
||||
PROJECT_SAMPLES_DIR = PACKAGE_DIR.parent / "librerias" / "organized_samples"
|
||||
SAMPLES_DIR = str(PROJECT_SAMPLES_DIR)
|
||||
|
||||
TRACK_LAYOUT = (
|
||||
("REFERENCE FULL", 59, 0.72, True),
|
||||
("REF DRUMS", 10, 0.84, False),
|
||||
("REF BASS", 30, 0.82, False),
|
||||
("REF OTHER", 50, 0.68, False),
|
||||
("REF VOCALS", 40, 0.70, False),
|
||||
)
|
||||
|
||||
SECTION_BLUEPRINTS = {
|
||||
"club": [
|
||||
("INTRO DJ", 16),
|
||||
("GROOVE A", 16),
|
||||
("VOCAL BUILD", 8),
|
||||
("DROP A", 16),
|
||||
("BREAKDOWN", 8),
|
||||
("BUILD B", 8),
|
||||
("DROP B", 16),
|
||||
("PEAK", 8),
|
||||
("OUTRO DJ", 16),
|
||||
],
|
||||
"standard": [
|
||||
("INTRO", 8),
|
||||
("BUILD", 8),
|
||||
("DROP A", 16),
|
||||
("BREAK", 8),
|
||||
("DROP B", 16),
|
||||
("OUTRO", 8),
|
||||
],
|
||||
}
|
||||
|
||||
|
||||
class AbletonSocketClient:
|
||||
def __init__(self, host: str = HOST, port: int = PORT):
|
||||
self.host = host
|
||||
self.port = port
|
||||
|
||||
def send(self, command_type: str, params: Dict[str, Any] | None = None, timeout: float = 30.0) -> Dict[str, Any]:
|
||||
payload = json.dumps({"type": command_type, "params": params or {}}, separators=(",", ":")).encode("utf-8") + MESSAGE_TERMINATOR
|
||||
with socket.create_connection((self.host, self.port), timeout=timeout) as sock:
|
||||
sock.sendall(payload)
|
||||
data = b""
|
||||
while not data.endswith(MESSAGE_TERMINATOR):
|
||||
chunk = sock.recv(65536)
|
||||
if not chunk:
|
||||
break
|
||||
data += chunk
|
||||
if not data:
|
||||
raise RuntimeError(f"Sin respuesta para {command_type}")
|
||||
return json.loads(data.decode("utf-8", errors="replace").strip())
|
||||
|
||||
|
||||
def _resolve_reference_profile(reference_path: Path) -> Dict[str, Any]:
|
||||
listener = ReferenceAudioListener(SAMPLES_DIR)
|
||||
analysis = listener.analyze_reference(str(reference_path))
|
||||
structure = "club" if analysis.get("duration", 0.0) >= 180 else "standard"
|
||||
return {
|
||||
"tempo": float(analysis.get("tempo", 128.0) or 128.0),
|
||||
"key": str(analysis.get("key", "") or ""),
|
||||
"duration": float(analysis.get("duration", 0.0) or 0.0),
|
||||
"structure": structure,
|
||||
"listener_device": analysis.get("device", "cpu"),
|
||||
}
|
||||
|
||||
|
||||
def ensure_reference_wav(reference_path: Path) -> Path:
|
||||
if reference_path.suffix.lower() == ".wav":
|
||||
return reference_path
|
||||
|
||||
if librosa is None:
|
||||
raise RuntimeError("librosa no está disponible para convertir la referencia a WAV")
|
||||
|
||||
wav_path = reference_path.with_suffix(".wav")
|
||||
if wav_path.exists() and wav_path.stat().st_size > 0:
|
||||
return wav_path
|
||||
|
||||
y, sr = librosa.load(str(reference_path), sr=44100, mono=False)
|
||||
if y.ndim == 1:
|
||||
y = y.reshape(1, -1)
|
||||
sf.write(str(wav_path), y.T, sr, subtype="PCM_16")
|
||||
return wav_path
|
||||
|
||||
|
||||
def separate_stems(reference_wav: Path, output_dir: Path) -> Dict[str, Path]:
|
||||
output_dir.mkdir(parents=True, exist_ok=True)
|
||||
stem_root = output_dir / reference_wav.stem
|
||||
expected = {
|
||||
"reference": reference_wav,
|
||||
"drums": stem_root / "drums.wav",
|
||||
"bass": stem_root / "bass.wav",
|
||||
"other": stem_root / "other.wav",
|
||||
"vocals": stem_root / "vocals.wav",
|
||||
}
|
||||
if all(path.exists() and path.stat().st_size > 0 for path in expected.values()):
|
||||
return expected
|
||||
|
||||
audio, sr = sf.read(str(reference_wav), always_2d=True)
|
||||
if sr != 44100:
|
||||
raise RuntimeError(f"Sample rate inesperado en referencia WAV: {sr}")
|
||||
|
||||
model = get_model("htdemucs")
|
||||
model.cpu()
|
||||
model.eval()
|
||||
waveform = torch.tensor(audio.T, dtype=torch.float32)
|
||||
separated = apply_model(model, waveform[None], device="cpu", progress=False)[0]
|
||||
|
||||
stem_root.mkdir(parents=True, exist_ok=True)
|
||||
for stem_name, tensor in zip(model.sources, separated):
|
||||
stem_path = stem_root / f"{stem_name}.wav"
|
||||
sf.write(str(stem_path), tensor.detach().cpu().numpy().T, sr, subtype="PCM_16")
|
||||
|
||||
return expected
|
||||
|
||||
|
||||
def _sections_for_structure(structure: str) -> List[Tuple[str, int]]:
|
||||
return list(SECTION_BLUEPRINTS.get(structure.lower(), SECTION_BLUEPRINTS["standard"]))
|
||||
|
||||
|
||||
def _create_track(client: AbletonSocketClient, name: str, color: int, volume: float) -> int:
|
||||
response = client.send("create_track", {"type": "audio", "index": -1})
|
||||
if response.get("status") != "success":
|
||||
raise RuntimeError(response.get("message", f"No se pudo crear {name}"))
|
||||
track_index = int(response.get("result", {}).get("index"))
|
||||
client.send("set_track_name", {"index": track_index, "name": name})
|
||||
client.send("set_track_color", {"index": track_index, "color": color})
|
||||
client.send("set_track_volume", {"index": track_index, "volume": volume})
|
||||
return track_index
|
||||
|
||||
|
||||
def _import_full_length_audio(client: AbletonSocketClient, track_index: int, file_path: Path, name: str) -> None:
|
||||
response = client.send("create_arrangement_audio_pattern", {
|
||||
"track_index": track_index,
|
||||
"file_path": str(file_path),
|
||||
"positions": [0.0],
|
||||
"name": name,
|
||||
}, timeout=120.0)
|
||||
if response.get("status") != "success":
|
||||
raise RuntimeError(response.get("message", f"No se pudo importar {name}"))
|
||||
|
||||
|
||||
def _prepare_navigation_scenes(client: AbletonSocketClient, structure: str) -> None:
|
||||
sections = _sections_for_structure(structure)
|
||||
session_info = client.send("get_session_info")
|
||||
if session_info.get("status") != "success":
|
||||
return
|
||||
|
||||
scene_count = int(session_info.get("result", {}).get("num_scenes", 0) or 0)
|
||||
target_count = len(sections)
|
||||
|
||||
while scene_count < target_count:
|
||||
create_response = client.send("create_scene", {"index": -1})
|
||||
if create_response.get("status") != "success":
|
||||
break
|
||||
scene_count += 1
|
||||
|
||||
while scene_count > target_count and scene_count > 1:
|
||||
delete_response = client.send("delete_scene", {"index": scene_count - 1})
|
||||
if delete_response.get("status") != "success":
|
||||
break
|
||||
scene_count -= 1
|
||||
|
||||
for scene_index, (section_name, _) in enumerate(sections):
|
||||
client.send("set_scene_name", {"index": scene_index, "name": section_name})
|
||||
|
||||
|
||||
def rebuild_project_from_reference(reference_path: Path) -> Dict[str, Any]:
|
||||
reference_path = reference_path.resolve()
|
||||
if not reference_path.exists():
|
||||
raise FileNotFoundError(reference_path)
|
||||
|
||||
profile = _resolve_reference_profile(reference_path)
|
||||
reference_wav = ensure_reference_wav(reference_path)
|
||||
stems = separate_stems(reference_wav, reference_path.parent / "stems")
|
||||
|
||||
client = AbletonSocketClient()
|
||||
clear_response = client.send("clear_project", {"keep_tracks": 0}, timeout=120.0)
|
||||
if clear_response.get("status") != "success":
|
||||
raise RuntimeError(clear_response.get("message", "No se pudo limpiar el proyecto"))
|
||||
|
||||
client.send("stop", {})
|
||||
client.send("set_tempo", {"tempo": round(profile["tempo"], 3)})
|
||||
client.send("show_arrangement_view", {})
|
||||
client.send("jump_to", {"time": 0})
|
||||
|
||||
created = []
|
||||
for (track_name, color, volume, muted), stem_key in zip(TRACK_LAYOUT, ("reference", "drums", "bass", "other", "vocals")):
|
||||
track_index = _create_track(client, track_name, color, volume)
|
||||
_import_full_length_audio(client, track_index, stems[stem_key], track_name)
|
||||
if muted:
|
||||
client.send("set_track_mute", {"index": track_index, "mute": True})
|
||||
created.append({
|
||||
"track_index": track_index,
|
||||
"name": track_name,
|
||||
"file_path": str(stems[stem_key]),
|
||||
})
|
||||
|
||||
_prepare_navigation_scenes(client, profile["structure"])
|
||||
client.send("loop_selection", {"start": 0, "length": max(32.0, round(profile["duration"] * profile["tempo"] / 60.0, 3)), "enable": False})
|
||||
client.send("jump_to", {"time": 0})
|
||||
client.send("show_arrangement_view", {})
|
||||
|
||||
session_info = client.send("get_session_info")
|
||||
return {
|
||||
"reference": str(reference_path),
|
||||
"tempo": profile["tempo"],
|
||||
"key": profile["key"],
|
||||
"structure": profile["structure"],
|
||||
"listener_device": profile["listener_device"],
|
||||
"stems": created,
|
||||
"session_info": session_info.get("result", {}),
|
||||
}
|
||||
|
||||
|
||||
def main() -> int:
|
||||
import argparse
|
||||
|
||||
parser = argparse.ArgumentParser(description="Rebuild an Ableton project directly from a reference track.")
|
||||
parser.add_argument("reference_path", help="Absolute or relative path to the reference audio file")
|
||||
args = parser.parse_args()
|
||||
|
||||
result = rebuild_project_from_reference(Path(args.reference_path))
|
||||
print(json.dumps(result, indent=2, ensure_ascii=False))
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
13
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/requirements.txt
Normal file
13
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/requirements.txt
Normal file
@@ -0,0 +1,13 @@
|
||||
# Dependencias de AbletonMCP-AI Server
|
||||
# Instalar con: pip install -r requirements.txt
|
||||
|
||||
mcp>=1.0.0
|
||||
# Servidor MCP FastMCP
|
||||
|
||||
# Opcional: para análisis de audio avanzado
|
||||
# numpy>=1.24.0
|
||||
# librosa>=0.10.0
|
||||
|
||||
# Opcional: para procesamiento con GPU AMD
|
||||
# torch==2.4.1
|
||||
# torch-directml>=0.2.5
|
||||
525
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/retrieval_benchmark.py
Normal file
525
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/retrieval_benchmark.py
Normal file
@@ -0,0 +1,525 @@
|
||||
"""
|
||||
retrieval_benchmark.py - Offline benchmark harness for retrieval quality inspection.
|
||||
|
||||
Analyzes reference tracks and outputs top-N candidates per role to help spot
|
||||
role contamination and evaluate retrieval quality.
|
||||
|
||||
Usage:
|
||||
python retrieval_benchmark.py --reference "path/to/track.mp3"
|
||||
python retrieval_benchmark.py --reference "track1.mp3" "track2.mp3" --top-n 10
|
||||
python retrieval_benchmark.py --reference "track.mp3" --output results.json --format json
|
||||
python retrieval_benchmark.py --reference "track.mp3" --output results.md --format markdown
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import logging
|
||||
import sys
|
||||
import time
|
||||
from collections import defaultdict
|
||||
from pathlib import Path
|
||||
from typing import Any, Dict, List, Optional
|
||||
|
||||
# Add parent directory to path for imports when running as script
|
||||
sys.path.insert(0, str(Path(__file__).parent))
|
||||
|
||||
from reference_listener import ReferenceAudioListener, ROLE_SEGMENT_SETTINGS
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
def _default_library_dir() -> Path:
|
||||
"""Get the default library directory."""
|
||||
return Path(__file__).resolve().parents[2] / "librerias" / "all_tracks"
|
||||
|
||||
|
||||
def run_benchmark(
|
||||
reference_paths: List[str],
|
||||
library_dir: Path,
|
||||
top_n: int = 10,
|
||||
roles: Optional[List[str]] = None,
|
||||
duration_limit: Optional[float] = None,
|
||||
) -> Dict[str, Any]:
|
||||
"""
|
||||
Run retrieval benchmark on one or more reference tracks.
|
||||
|
||||
Args:
|
||||
reference_paths: List of paths to reference audio files
|
||||
library_dir: Path to the sample library
|
||||
top_n: Number of top candidates to show per role
|
||||
roles: Optional list of specific roles to analyze
|
||||
duration_limit: Optional duration limit for analysis
|
||||
|
||||
Returns:
|
||||
Dict containing benchmark results for each reference
|
||||
"""
|
||||
listener = ReferenceAudioListener(str(library_dir))
|
||||
|
||||
all_roles = list(ROLE_SEGMENT_SETTINGS.keys())
|
||||
target_roles = [r for r in (roles or all_roles) if r in all_roles]
|
||||
|
||||
results = {
|
||||
"benchmark_info": {
|
||||
"library_dir": str(library_dir),
|
||||
"top_n": top_n,
|
||||
"roles": target_roles,
|
||||
"timestamp": time.strftime("%Y-%m-%dT%H:%M:%S"),
|
||||
"device": listener.device_name,
|
||||
},
|
||||
"references": [],
|
||||
}
|
||||
|
||||
for ref_path in reference_paths:
|
||||
ref_path = Path(ref_path)
|
||||
if not ref_path.exists():
|
||||
logger.warning("Reference file not found: %s", ref_path)
|
||||
continue
|
||||
|
||||
logger.info("Analyzing reference: %s", ref_path.name)
|
||||
|
||||
try:
|
||||
start_time = time.time()
|
||||
|
||||
# Run match_assets to get candidates per role
|
||||
match_result = listener.match_assets(str(ref_path))
|
||||
reference_info = match_result.get("reference", {})
|
||||
matches = match_result.get("matches", {})
|
||||
|
||||
elapsed = time.time() - start_time
|
||||
|
||||
ref_result = {
|
||||
"file_name": ref_path.name,
|
||||
"path": str(ref_path),
|
||||
"analysis_time_seconds": round(elapsed, 2),
|
||||
"reference_info": {
|
||||
"tempo": reference_info.get("tempo"),
|
||||
"key": reference_info.get("key"),
|
||||
"duration": reference_info.get("duration"),
|
||||
"rms_mean": reference_info.get("rms_mean"),
|
||||
"onset_mean": reference_info.get("onset_mean"),
|
||||
"spectral_centroid": reference_info.get("spectral_centroid"),
|
||||
},
|
||||
"sections": [
|
||||
{
|
||||
"kind": s.get("kind"),
|
||||
"start": s.get("start"),
|
||||
"end": s.get("end"),
|
||||
"bars": s.get("bars"),
|
||||
}
|
||||
for s in match_result.get("reference_sections", [])
|
||||
],
|
||||
"role_candidates": {},
|
||||
}
|
||||
|
||||
# Process each role
|
||||
for role in target_roles:
|
||||
role_matches = matches.get(role, [])
|
||||
top_candidates = role_matches[:top_n]
|
||||
|
||||
ref_result["role_candidates"][role] = {
|
||||
"total_available": len(role_matches),
|
||||
"top_candidates": [
|
||||
{
|
||||
"rank": i + 1,
|
||||
"file_name": c.get("file_name"),
|
||||
"path": c.get("path"),
|
||||
"score": c.get("score"),
|
||||
"cosine": c.get("cosine"),
|
||||
"segment_score": c.get("segment_score"),
|
||||
"catalog_score": c.get("catalog_score"),
|
||||
"tempo": c.get("tempo"),
|
||||
"key": c.get("key"),
|
||||
"duration": c.get("duration"),
|
||||
}
|
||||
for i, c in enumerate(top_candidates)
|
||||
],
|
||||
}
|
||||
|
||||
results["references"].append(ref_result)
|
||||
logger.info("Completed analysis in %.2fs", elapsed)
|
||||
|
||||
except Exception as e:
|
||||
logger.error("Failed to analyze %s: %s", ref_path, e, exc_info=True)
|
||||
results["references"].append({
|
||||
"file_name": ref_path.name,
|
||||
"path": str(ref_path),
|
||||
"error": str(e),
|
||||
})
|
||||
|
||||
return results
|
||||
|
||||
|
||||
def analyze_role_contamination(results: Dict[str, Any]) -> Dict[str, Any]:
|
||||
"""
|
||||
Analyze results for potential role contamination issues.
|
||||
|
||||
Returns a dict with contamination analysis:
|
||||
- files appearing in multiple roles
|
||||
- misnamed files (e.g., "bass" appearing in "kick" role)
|
||||
- score distribution anomalies
|
||||
"""
|
||||
contamination = {
|
||||
"cross_role_files": [],
|
||||
"potential_mismatches": [],
|
||||
"role_score_stats": {},
|
||||
}
|
||||
|
||||
# Track files appearing in multiple roles
|
||||
file_to_roles: Dict[str, List[Dict[str, Any]]] = defaultdict(list)
|
||||
|
||||
for ref in results.get("references", []):
|
||||
ref_name = ref.get("file_name", "unknown")
|
||||
|
||||
for role, role_data in ref.get("role_candidates", {}).items():
|
||||
for candidate in role_data.get("top_candidates", []):
|
||||
file_name = candidate.get("file_name", "")
|
||||
if file_name:
|
||||
file_to_roles[file_name].append({
|
||||
"reference": ref_name,
|
||||
"role": role,
|
||||
"rank": candidate.get("rank"),
|
||||
"score": candidate.get("score"),
|
||||
})
|
||||
|
||||
# Find files appearing in multiple roles
|
||||
for file_name, appearances in file_to_roles.items():
|
||||
unique_roles = set(a["role"] for a in appearances)
|
||||
if len(unique_roles) > 1:
|
||||
contamination["cross_role_files"].append({
|
||||
"file_name": file_name,
|
||||
"roles": list(unique_roles),
|
||||
"appearances": appearances,
|
||||
})
|
||||
|
||||
# Check for potential mismatches (filename suggests different role)
|
||||
role_keywords = {
|
||||
"kick": ["kick"],
|
||||
"snare": ["snare", "clap"],
|
||||
"hat": ["hat", "hihat", "hi-hat"],
|
||||
"bass_loop": ["bass", "sub", "808"],
|
||||
"perc_loop": ["perc", "percussion", "conga", "bongo"],
|
||||
"top_loop": ["top", "drum loop", "full drum"],
|
||||
"synth_loop": ["synth", "lead", "pad", "chord", "arp"],
|
||||
"vocal_loop": ["vocal", "vox", "acapella"],
|
||||
"crash_fx": ["crash", "cymbal", "impact"],
|
||||
"fill_fx": ["fill", "transition", "tom"],
|
||||
"snare_roll": ["roll", "snareroll"],
|
||||
"atmos_fx": ["atmos", "drone", "ambient", "texture"],
|
||||
"vocal_shot": ["shot", "vocal shot", "chop"],
|
||||
}
|
||||
|
||||
for ref in results.get("references", []):
|
||||
for role, role_data in ref.get("role_candidates", {}).items():
|
||||
for candidate in role_data.get("top_candidates", []):
|
||||
file_name = candidate.get("file_name", "").lower()
|
||||
if not file_name:
|
||||
continue
|
||||
|
||||
# Check if file name suggests a different role
|
||||
expected_keywords = role_keywords.get(role, [])
|
||||
other_role_matches = []
|
||||
|
||||
for other_role, keywords in role_keywords.items():
|
||||
if other_role == role:
|
||||
continue
|
||||
if any(kw in file_name for kw in keywords):
|
||||
other_role_matches.append(other_role)
|
||||
|
||||
if other_role_matches and expected_keywords:
|
||||
# File name matches another role but not this one
|
||||
if not any(kw in file_name for kw in expected_keywords):
|
||||
contamination["potential_mismatches"].append({
|
||||
"file_name": candidate.get("file_name"),
|
||||
"assigned_role": role,
|
||||
"rank": candidate.get("rank"),
|
||||
"score": candidate.get("score"),
|
||||
"suggested_roles": other_role_matches,
|
||||
})
|
||||
|
||||
# Calculate score distribution per role
|
||||
for ref in results.get("references", []):
|
||||
for role, role_data in ref.get("role_candidates", {}).items():
|
||||
scores = [
|
||||
c.get("score", 0)
|
||||
for c in role_data.get("top_candidates", [])
|
||||
if c.get("score") is not None
|
||||
]
|
||||
|
||||
if scores:
|
||||
contamination["role_score_stats"][role] = {
|
||||
"min": round(min(scores), 4),
|
||||
"max": round(max(scores), 4),
|
||||
"avg": round(sum(scores) / len(scores), 4),
|
||||
"count": len(scores),
|
||||
}
|
||||
|
||||
return contamination
|
||||
|
||||
|
||||
def format_output_json(results: Dict[str, Any]) -> str:
|
||||
"""Format results as JSON string."""
|
||||
return json.dumps(results, indent=2, ensure_ascii=False)
|
||||
|
||||
|
||||
def format_output_markdown(results: Dict[str, Any]) -> str:
|
||||
"""Format results as markdown string."""
|
||||
lines = []
|
||||
|
||||
# Header
|
||||
lines.append("# Retrieval Benchmark Report")
|
||||
lines.append("")
|
||||
lines.append(f"**Generated:** {results['benchmark_info']['timestamp']}")
|
||||
lines.append(f"**Library:** `{results['benchmark_info']['library_dir']}`")
|
||||
lines.append(f"**Top N:** {results['benchmark_info']['top_n']}")
|
||||
lines.append(f"**Device:** {results['benchmark_info']['device']}")
|
||||
lines.append("")
|
||||
|
||||
# Process each reference
|
||||
for ref in results.get("references", []):
|
||||
lines.append(f"## Reference: {ref.get('file_name', 'unknown')}")
|
||||
lines.append("")
|
||||
|
||||
# Error case
|
||||
if "error" in ref:
|
||||
lines.append(f"**Error:** {ref['error']}")
|
||||
lines.append("")
|
||||
continue
|
||||
|
||||
# Reference info
|
||||
ref_info = ref.get("reference_info", {})
|
||||
lines.append("### Reference Analysis")
|
||||
lines.append("")
|
||||
lines.append("| Property | Value |")
|
||||
lines.append("|----------|-------|")
|
||||
lines.append(f"| Tempo | {ref_info.get('tempo', 'N/A')} BPM |")
|
||||
lines.append(f"| Key | {ref_info.get('key', 'N/A')} |")
|
||||
lines.append(f"| Duration | {ref_info.get('duration', 'N/A')}s |")
|
||||
lines.append(f"| RMS Mean | {ref_info.get('rms_mean', 'N/A')} |")
|
||||
lines.append(f"| Onset Mean | {ref_info.get('onset_mean', 'N/A')} |")
|
||||
lines.append(f"| Spectral Centroid | {ref_info.get('spectral_centroid', 'N/A')} Hz |")
|
||||
lines.append("")
|
||||
|
||||
# Sections
|
||||
sections = ref.get("sections", [])
|
||||
if sections:
|
||||
lines.append("### Detected Sections")
|
||||
lines.append("")
|
||||
lines.append("| Type | Start | End | Bars |")
|
||||
lines.append("|------|-------|-----|------|")
|
||||
for s in sections:
|
||||
lines.append(f"| {s.get('kind', 'N/A')} | {s.get('start', 'N/A')}s | {s.get('end', 'N/A')}s | {s.get('bars', 'N/A')} |")
|
||||
lines.append("")
|
||||
|
||||
# Role candidates
|
||||
lines.append("### Top Candidates per Role")
|
||||
lines.append("")
|
||||
|
||||
for role, role_data in ref.get("role_candidates", {}).items():
|
||||
total = role_data.get("total_available", 0)
|
||||
lines.append(f"#### {role} ({total} available)")
|
||||
lines.append("")
|
||||
|
||||
candidates = role_data.get("top_candidates", [])
|
||||
if not candidates:
|
||||
lines.append("*No candidates found*")
|
||||
lines.append("")
|
||||
continue
|
||||
|
||||
lines.append("| Rank | File | Score | Cosine | Seg | Catalog | Tempo | Key | Duration |")
|
||||
lines.append("|------|------|-------|--------|-----|---------|-------|-----|----------|")
|
||||
|
||||
for c in candidates:
|
||||
lines.append(
|
||||
f"| {c.get('rank', 'N/A')} | "
|
||||
f"`{c.get('file_name', 'N/A')[:40]}` | "
|
||||
f"{c.get('score', 0):.4f} | "
|
||||
f"{c.get('cosine', 0):.4f} | "
|
||||
f"{c.get('segment_score', 0):.4f} | "
|
||||
f"{c.get('catalog_score', 0):.4f} | "
|
||||
f"{c.get('tempo', 'N/A')} | "
|
||||
f"{c.get('key', 'N/A')} | "
|
||||
f"{c.get('duration', 'N/A'):.2f}s |"
|
||||
)
|
||||
lines.append("")
|
||||
|
||||
# Contamination analysis
|
||||
if "contamination_analysis" in results:
|
||||
contam = results["contamination_analysis"]
|
||||
lines.append("## Role Contamination Analysis")
|
||||
lines.append("")
|
||||
|
||||
# Cross-role files
|
||||
cross_role = contam.get("cross_role_files", [])
|
||||
if cross_role:
|
||||
lines.append("### Files Appearing in Multiple Roles")
|
||||
lines.append("")
|
||||
for item in cross_role:
|
||||
lines.append(f"- **{item['file_name']}**")
|
||||
lines.append(f" - Roles: {', '.join(item['roles'])}")
|
||||
for app in item["appearances"]:
|
||||
lines.append(f" - {app['role']}: rank {app['rank']}, score {app['score']:.4f}")
|
||||
lines.append("")
|
||||
|
||||
# Potential mismatches
|
||||
mismatches = contam.get("potential_mismatches", [])
|
||||
if mismatches:
|
||||
lines.append("### Potential Role Mismatches")
|
||||
lines.append("")
|
||||
lines.append("Files whose names suggest a different role than assigned:")
|
||||
lines.append("")
|
||||
for item in mismatches:
|
||||
lines.append(f"- **{item['file_name']}**")
|
||||
lines.append(f" - Assigned: {item['assigned_role']} (rank {item['rank']}, score {item['score']:.4f})")
|
||||
lines.append(f" - Suggested: {', '.join(item['suggested_roles'])}")
|
||||
lines.append("")
|
||||
|
||||
# Score stats
|
||||
score_stats = contam.get("role_score_stats", {})
|
||||
if score_stats:
|
||||
lines.append("### Score Distribution per Role")
|
||||
lines.append("")
|
||||
lines.append("| Role | Min | Max | Avg | Count |")
|
||||
lines.append("|------|-----|-----|-----|-------|")
|
||||
for role, stats in sorted(score_stats.items()):
|
||||
lines.append(
|
||||
f"| {role} | {stats['min']:.4f} | {stats['max']:.4f} | "
|
||||
f"{stats['avg']:.4f} | {stats['count']} |"
|
||||
)
|
||||
lines.append("")
|
||||
|
||||
return "\n".join(lines)
|
||||
|
||||
|
||||
def main() -> int:
|
||||
parser = argparse.ArgumentParser(
|
||||
description="Offline benchmark harness for retrieval quality inspection.",
|
||||
formatter_class=argparse.RawDescriptionHelpFormatter,
|
||||
epilog="""
|
||||
Examples:
|
||||
%(prog)s --reference "track.mp3"
|
||||
%(prog)s --reference "track1.mp3" "track2.mp3" --top-n 15
|
||||
%(prog)s --reference "track.mp3" --output results.md --format markdown
|
||||
%(prog)s --reference "track.mp3" --roles kick snare hat --top-n 20
|
||||
""",
|
||||
)
|
||||
|
||||
parser.add_argument(
|
||||
"--reference", "-r",
|
||||
nargs="+",
|
||||
required=True,
|
||||
help="One or more reference audio files to analyze",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--library-dir",
|
||||
default=str(_default_library_dir()),
|
||||
help="Audio library directory (default: ../librerias/all_tracks)",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--top-n", "-n",
|
||||
type=int,
|
||||
default=10,
|
||||
help="Number of top candidates to show per role (default: 10)",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--roles",
|
||||
nargs="*",
|
||||
default=None,
|
||||
help="Specific roles to analyze (default: all roles)",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--output", "-o",
|
||||
type=str,
|
||||
default=None,
|
||||
help="Output file path for results",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--format", "-f",
|
||||
choices=["json", "markdown", "md"],
|
||||
default=None,
|
||||
help="Output format (json or markdown). Auto-detected from output file extension if not specified.",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--analyze-contamination",
|
||||
action="store_true",
|
||||
help="Include role contamination analysis in output",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--verbose", "-v",
|
||||
action="store_true",
|
||||
help="Enable verbose logging",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--duration-limit",
|
||||
type=float,
|
||||
default=None,
|
||||
help="Optional duration limit for audio analysis",
|
||||
)
|
||||
|
||||
args = parser.parse_args()
|
||||
|
||||
# Configure logging
|
||||
if args.verbose:
|
||||
logging.basicConfig(level=logging.DEBUG, format="%(levelname)s: %(message)s")
|
||||
else:
|
||||
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
|
||||
|
||||
# Validate reference files
|
||||
reference_paths = []
|
||||
for ref in args.reference:
|
||||
ref_path = Path(ref)
|
||||
if ref_path.exists():
|
||||
reference_paths.append(str(ref_path))
|
||||
else:
|
||||
logger.warning("Reference file not found: %s", ref)
|
||||
|
||||
if not reference_paths:
|
||||
logger.error("No valid reference files provided")
|
||||
return 1
|
||||
|
||||
# Run benchmark
|
||||
logger.info("Running retrieval benchmark on %d reference(s)", len(reference_paths))
|
||||
|
||||
results = run_benchmark(
|
||||
reference_paths=reference_paths,
|
||||
library_dir=Path(args.library_dir),
|
||||
top_n=args.top_n,
|
||||
roles=args.roles,
|
||||
duration_limit=args.duration_limit,
|
||||
)
|
||||
|
||||
# Add contamination analysis if requested
|
||||
if args.analyze_contamination:
|
||||
logger.info("Analyzing role contamination...")
|
||||
results["contamination_analysis"] = analyze_role_contamination(results)
|
||||
|
||||
# Determine output format
|
||||
output_format = args.format
|
||||
if output_format is None and args.output:
|
||||
output_format = "markdown" if args.output.endswith(".md") else "json"
|
||||
output_format = output_format or "text"
|
||||
|
||||
# Format output
|
||||
if output_format in ("markdown", "md"):
|
||||
output_text = format_output_markdown(results)
|
||||
elif output_format == "json":
|
||||
output_text = format_output_json(results)
|
||||
else:
|
||||
# Plain text summary
|
||||
output_text = format_output_markdown(results)
|
||||
|
||||
# Write to file or stdout
|
||||
if args.output:
|
||||
output_path = Path(args.output)
|
||||
output_path.parent.mkdir(parents=True, exist_ok=True)
|
||||
output_path.write_text(output_text, encoding="utf-8")
|
||||
logger.info("Results written to: %s", output_path)
|
||||
else:
|
||||
print(output_text)
|
||||
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
508
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/roadmap.md
Normal file
508
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/roadmap.md
Normal file
@@ -0,0 +1,508 @@
|
||||
# 🎛️ ROADMAP — AbletonMCP_AI hacia DJ Profesional
|
||||
|
||||
> Última revisión: 2026-03-22
|
||||
> Objetivo: Sistema MCP capaz de generar, mezclar y performar sets de música electrónica a nivel profesional de club.
|
||||
|
||||
---
|
||||
|
||||
## 🎯 Visión General
|
||||
|
||||
```
|
||||
FASE 1 → FASE 2 → FASE 3 → FASE 4 → FASE 5
|
||||
Gain Estructura Efectos Análisis Transiciones
|
||||
Staging Pro Creativos Avanzado DJ
|
||||
|
||||
FASE 6 → FASE 7 → FASE 8 → FASE 9 → FASE 10
|
||||
Set Melodía Mastering Colaboración DJ Autónomo
|
||||
Planning Generativa Label & Versionado Completo
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Estado Actual del Sistema
|
||||
|
||||
| Módulo | Estado | Nivel Actual | Nivel Objetivo |
|
||||
|---|---|---|---|
|
||||
| Drum Pattern Generation | ✅ Funcional | ★★★☆☆ | ★★★★★ |
|
||||
| Sample Selection | ✅ Funcional | ★★★☆☆ | ★★★★★ |
|
||||
| Gain Staging | 🔧 Parcial | ★★☆☆☆ | ★★★★★ |
|
||||
| Track Structure | ✅ Funcional | ★★★☆☆ | ★★★★★ |
|
||||
| Reference Analysis | ✅ Funcional | ★★★☆☆ | ★★★★★ |
|
||||
| Creative FX | 🔧 Parcial | ★★☆☆☆ | ★★★★☆ |
|
||||
| DJ Transitions | ❌ Sin implementar | ★☆☆☆☆ | ★★★★★ |
|
||||
| Set Planning | ❌ Sin implementar | ★☆☆☆☆ | ★★★★★ |
|
||||
| Generative Melody | ❌ Sin implementar | ★☆☆☆☆ | ★★★★☆ |
|
||||
| Mastering | ❌ Sin implementar | ★☆☆☆☆ | ★★★★★ |
|
||||
|
||||
---
|
||||
|
||||
## FASE 1 — Gain Staging Profesional (Fundamento del Mix)
|
||||
> _Prioridad: CRÍTICA · Estimado: 2-3 semanas_
|
||||
|
||||
La mayoría de los problemas de volumen bajo y falta de punch vienen de este bloque. Sin un gain staging correcto, todo lo demás falla.
|
||||
|
||||
### 1.1 Normalización por LUFS
|
||||
- [ ] **Pre-fader LUFS** — cada sample se analiza y se normaliza a -18 LUFS antes de entrar al track
|
||||
- [ ] **LUFS por rol** — kick a -12 LUFS, snare a -14 LUFS, hat a -20 LUFS, bass a -16 LUFS (relaciones estándar)
|
||||
- [ ] **Momentary vs integrated** — usar integrated LUFS para samples estáticos, momentary para loops
|
||||
- [ ] **True peak awareness** — detectar clipeo en true peak, no solo sample peak
|
||||
- [ ] **Headroom budget** — distribuir el headroom disponible entre roles con un modelo de "presupuesto de dB"
|
||||
|
||||
### 1.2 Relaciones de Ganancia entre Roles
|
||||
- [ ] **Drum bus total** — suma de todos los drums a -10 LUFS antes del bus
|
||||
- [ ] **Bass vs kick relationship** — el kick debe ganar 2-4 dB al bass en el impacto (punch vs sustain)
|
||||
- [ ] **Vocal/melody ducking** — melodías y vocales 3-6 dB por debajo del bus de batería en el drop
|
||||
- [ ] **FX track attenuation** — todos los FX y atmos a -20 LUFS o menos para no saturar el mix
|
||||
- [ ] **Reference comparison** — calcular diferencia de LUFS entre la generación y la referencia, ajustar
|
||||
|
||||
### 1.3 Bus Routing y Suma
|
||||
- [ ] **Drums bus** — kick, snare, hat, perc → Drum Bus con glue compression leve (+2 dB make-up)
|
||||
- [ ] **Bass bus** — bass loop + sub → Bass Bus con limiting en -6 dBFS
|
||||
- [ ] **Music bus** — synths, chords, melodía → Music Bus con suave saturación analógica
|
||||
- [ ] **Vocal bus** — vocal loops, vocal shots → Vocal Bus con de-esser automático
|
||||
- [ ] **FX bus** — atmos, risers, downlifters → FX Bus sin compresión, reverb send global
|
||||
- [ ] **Master bus** — suma de todos los buses con limitador final a -0.3 dBFS
|
||||
|
||||
### 1.4 Side-chain Automático
|
||||
- [ ] **Kick → Bass** — el kick ducka el bass 8-10 dB con release de 80-150ms (el sonido más icónico del house/techno)
|
||||
- [ ] **Kick → Pad** — ducking leve de 2-4 dB en pads para que el kick respire
|
||||
- [ ] **Kick → Reverb send** — el kick reduce el reverb send durante su impulso (más punch)
|
||||
- [ ] **Snare → Music bus** — el snare ducka suavemente el bus de música en el drop
|
||||
- [ ] **Sidechain curve configuración** — curvas de ataque/release distintas por género (hard techno vs deep house)
|
||||
|
||||
### 1.5 Calibración de Instrumentos Ableton
|
||||
- [ ] **Simpler gain staging** — todos los clips en Simpler/Sampler con ganancia a 0 dB, nivel ajustado en pista
|
||||
- [ ] **Pre/Post fader envíos** — envíos de reverb/delay siempre en post-fader
|
||||
- [ ] **Return track levels** — return de reverb a -6 dB, return de delay a -12 dB como punto inicial
|
||||
- [ ] **Verificar master output** — nunca superar -0.1 dBFS en pico en la master antes del limitador
|
||||
|
||||
---
|
||||
|
||||
## FASE 2 — Estructura de Track y Arrangement Profesional
|
||||
> _Prioridad: ALTA · Estimado: 3-4 semanas_
|
||||
|
||||
### 2.1 Arquitectura de Secciones
|
||||
- [ ] **Intro largo (32+ bars)** — intro mezclable: solo kick + elementos mínimos para que el DJ anterior pueda salir
|
||||
- [ ] **Warmup section (16 bars)** — añadir elementos gradualmente, hat entra a los 8 bars, bass a los 16
|
||||
- [ ] **First drop (8-16 bars)** — primer drop con todos los elementos, más corto que el segundo
|
||||
- [ ] **Breakdown/Stripped (16-32 bars)** — quitar todo excepto melody/atmos, crear tensión
|
||||
- [ ] **Buildup (8-16 bars)** — capas que se van sumando, sweep, riser, snare roll, tensión creciente
|
||||
- [ ] **Main drop (16-32 bars)** — el momento de mayor energía, todos los elementos, impacto completo
|
||||
- [ ] **Second breakdown** — variación del primero, puede tener elementos distintos
|
||||
- [ ] **Second buildup** — más intenso que el first buildup
|
||||
- [ ] **Re-drop / Peak (16-32 bars)** — más fuerte que el main drop, puede tener nuevo elemento
|
||||
- [ ] **Outro (32+ bars)** — mirror del intro, quitar elementos progresivamente para facilitar mezcla de salida
|
||||
|
||||
### 2.2 Dinámica de Energía
|
||||
- [ ] **Energy curve modeling** — modelar la curva de energía como función matemática (no plana)
|
||||
- [ ] **Sectional density** — calcular cuántos elementos hay activos en cada momento, mantener balance
|
||||
- [ ] **Tension → Release** — cada breakdown debe crear tensión medible (menos energía → expectativa)
|
||||
- [ ] **Drop impact scoring** — el drop debe tener al menos 30% más energía que la última sección tranquila
|
||||
- [ ] **Post-drop variation** — segunda mitad del drop con variación para mantener el interés
|
||||
|
||||
### 2.3 Fills y Transiciones Internas
|
||||
- [ ] **Bar 7-8 fill** — percusión extra o variación de patrón cada 8 compases
|
||||
- [ ] **16-bar macro fill** — cambio más notable cada 16 compases (nuevo elemento, variación de synth)
|
||||
- [ ] **Snare roll entrance** — snare roll de 4 barras antes de cada drop
|
||||
- [ ] **Crash/cymbal hit** — crash en el primer beat del drop (elemento crítico en dance music)
|
||||
- [ ] **Filter automation** — high-pass filter que sube en buildup y se abre en el drop
|
||||
- [ ] **Riser placement** — riser de 8-16 barras que termina exactamente en el primer beat del drop
|
||||
- [ ] **Downlifter exit** — downlifter al final de los drops para marcar el end
|
||||
|
||||
### 2.4 Variación Melódica
|
||||
- [ ] **A/B hook structure** — dos versiones del hook principal (A en primer drop, B en re-drop)
|
||||
- [ ] **Chord substitution** — reemplazar uno de los acordes de la progresión en la segunda pasada
|
||||
- [ ] **Octave variation** — mover la melodía una octava arriba/abajo en el re-drop
|
||||
- [ ] **Call and response** — alternar frases entre dos elementos (ej: synth → respuesta de bass)
|
||||
- [ ] **Breakdown melody** — melodía simplificada o reducida durante el breakdown (solo notas principales)
|
||||
|
||||
---
|
||||
|
||||
## FASE 3 — Efectos y Procesamiento Creativo
|
||||
> _Prioridad: ALTA · Estimado: 3-4 semanas_
|
||||
|
||||
### 3.1 Reverb Inteligente por Sección
|
||||
- [ ] **Reverb macro** — controlar el tamaño de reverb global por sección (pequeño en drop, enorme en breakdown)
|
||||
- [ ] **Reverb por instrumento** — kick con room corto, snare con plate medio, pads con hall largo
|
||||
- [ ] **Pre-delay automático** — pre-delay del reverb sincronizado al BPM para mantener intelligibility
|
||||
- [ ] **Reverb automation curves** — el reverb crece durante el buildup, se corta en el drop (gate de reverb)
|
||||
- [ ] **Reverb freeze** — congelar el reverb tail al final del breakdown para el "moment of silence"
|
||||
|
||||
### 3.2 Delay Creativo
|
||||
- [ ] **BPM-sync delay** — delay en tempo: 1/8, 1/4, 3/16 según el instrumento
|
||||
- [ ] **Ping-pong delay** — delays stereo alternados en synths y vocales
|
||||
- [ ] **Filtered delay** — delay con high-pass y low-pass para no ensuciar frecuencias
|
||||
- [ ] **Delay throw** — mandar el último beat de una frase al delay para extenderla naturalmente
|
||||
- [ ] **Slapback delay** — delay muy corto (30-70ms) en vocales para darles presencia
|
||||
|
||||
### 3.3 Modulación y Movimiento
|
||||
- [ ] **Auto-filter LFO** — filtro con LFO sincronizado al tempo en bass loops y synths
|
||||
- [ ] **Phaser/Flanger automático** — aplicar phaser en el breakdown para crear movimiento sin samples
|
||||
- [ ] **Chorus en strings/pads** — chorus sutil para engrosar pads y darles width
|
||||
- [ ] **Tremolo rítmico** — volumen modulado en 1/8 o 1/16 para efectos de rapidez
|
||||
- [ ] **Pitch modulation** — vibrato leve en melodías para humanizarlas
|
||||
|
||||
### 3.4 Distorsión y Saturación Creativa
|
||||
- [ ] **Analog warmth en bass** — saturación leve (1-3%) en bass para armónicos
|
||||
- [ ] **Tape saturation en drums** — simular cinta en el drum bus para punch y cohesión
|
||||
- [ ] **Bitcrusher en FX** — bitcrush en 8-bit durante buildups para crear tensión digital
|
||||
- [ ] **Distortion send** — send bus de distorsión para añadir agresividad selectivamente
|
||||
- [ ] **Clip distortion** — distorsión suave en kick para añadir transiente agresivo
|
||||
|
||||
### 3.5 Stereo Image y Espacialidad
|
||||
- [ ] **Mono bajo 200 Hz** — todo el contenido de sub-bass en mono (estándar de mastering)
|
||||
- [ ] **Width por instrumento** — kick y bass mono, pads width 120%, melodías width 80%
|
||||
- [ ] **Haas effect** — leve delay de 20-40ms en canal derecho vs izquierdo para ampliar imagen
|
||||
- [ ] **M/S processing en mix** — comprimir el mid separado del side para control de espacio
|
||||
- [ ] **Stereo field visualization** — calcular y reportar la correlación estéreo del mix
|
||||
|
||||
### 3.6 EQ Dinámico y Automático
|
||||
- [ ] **Dynamic EQ en bajos** — cortar sub-bass automáticamente cuando es demasiado denso
|
||||
- [ ] **Frequency clash detection** — detectar dos instrumentos que ocupan la misma frecuencia y EQ a uno
|
||||
- [ ] **HP/LP automatizado por sección** — aplicar filtros distintos según si es intro, drop, breakdown
|
||||
- [ ] **Shelf EQ en master** — leve boost de high shelf (+0.5 dB a 10kHz) para aire en el mix
|
||||
- [ ] **Low-end balance report** — calcular energía de sub vs mid-bass y reportar desbalance
|
||||
|
||||
---
|
||||
|
||||
## FASE 4 — Análisis de Referencia Avanzado
|
||||
> _Prioridad: ALTA · Estimado: 4-5 semanas_
|
||||
|
||||
### 4.1 Stem Separation de Referencia
|
||||
- [ ] **Integración Demucs** — separar stems de tracks comerciales (drums, bass, melody, vocal, other)
|
||||
- [ ] **Kick isolation** — extraer solo el kick de la referencia para analizar tono y punch
|
||||
- [ ] **Bass isolation** — analizar frecuencia fundamental, movimiento y sidechain de la referencia
|
||||
- [ ] **Dry melody extraction** — extraer melodía sin reverb de la referencia para comparar tonalidad
|
||||
- [ ] **FX layer identification** — identificar qué es FX/atmos vs contenido musical en la referencia
|
||||
|
||||
### 4.2 Groove y Timing Analysis
|
||||
- [ ] **Swing extraction** — medir el swing (desplazamiento del tempo) de la referencia en ms
|
||||
- [ ] **Groove template** — aplicar el groove de la referencia a los drum patterns generados
|
||||
- [ ] **Velocity curve** — analizar la dinámica de velocidad (qué hits son más fuertes) y replicarla
|
||||
- [ ] **Ghost note detection** — detectar ghost notes en la batería de referencia e insertarlas
|
||||
- [ ] **Micro-timing humanization** — añadir variaciones de 2-8ms en los hits para humanizar el patrón
|
||||
|
||||
### 4.3 Spectral Fingerprinting
|
||||
- [ ] **Frequency balance snapshot** — captura del balance espectral (sub/low/mid/high) de la referencia
|
||||
- [ ] **Spectral tilt** — medir si la referencia tiene más energía en graves o agudos y replicarlo
|
||||
- [ ] **Harmonic series analysis** — identificar los armónicos dominantes del mix de referencia
|
||||
- [ ] **Noise floor level** — medir el noise floor de la referencia (algunos géneros tienen ruido intencional)
|
||||
- [ ] **Transient vs sustained ratio** — relación entre sonidos percusivos y sostenidos en la mezcla
|
||||
|
||||
### 4.4 Arrangement Cloning
|
||||
- [ ] **Section boundary detection** — detectar automáticamente dónde empiezan intro, drops, breakdowns
|
||||
- [ ] **Element entrance mapping** — mapear qué elementos entran/salen en cada sección
|
||||
- [ ] **Dynamic range curve** — medir la curva de dinámicas a lo largo del track y replicarla
|
||||
- [ ] **Repetition pattern** — detectar cuánto se repiten las secciones (4/8/16 bars) y aplicarlo
|
||||
- [ ] **Surprise element detection** — identificar momentos inesperados en la referencia (cambios de tempo, key changes)
|
||||
|
||||
### 4.5 Plugin Chain Matching
|
||||
- [ ] **Compression footprint** — inferir el tipo de compresión usado (attack lento/rápido, ratio alto/bajo)
|
||||
- [ ] **Reverb character** — inferir tamaño y decay del reverb más usado en la referencia
|
||||
- [ ] **Saturation type** — distinguir saturation analógica de distorsión digital en la referencia
|
||||
- [ ] **Vocal processing chain** — inferir qué procesamiento tiene el vocal (tuning, de-ess, comp)
|
||||
- [ ] **Master chain inference** — inferir si la referencia tiene limitador suave o hard, saturación de cinta, etc.
|
||||
|
||||
---
|
||||
|
||||
## FASE 5 — Motor de Transiciones DJ
|
||||
> _Prioridad: MUY ALTA · Estimado: 5-6 semanas_
|
||||
|
||||
### 5.1 Análisis de Compatibilidad Entre Tracks
|
||||
- [ ] **BPM compatibility score** — calcular distancia de BPM y si requiere pitch shifting
|
||||
- [ ] **Key compatibility (Camelot Wheel)** — verificar que los dos tracks sean armónicamente compatibles
|
||||
- [ ] **Energy level matching** — el track entrante debe tener energía similar al punto de mezcla actual
|
||||
- [ ] **Frequency clash in overlap** — detectar si los dos tracks generan mud en la zona de mezcla
|
||||
- [ ] **Structural alignment** — alinear las frases musicales (el drop del track B sobre el drop del track A)
|
||||
- [ ] **Genre fluidity score** — medir cuán compatible es el cambio de sub-género entre tracks
|
||||
|
||||
### 5.2 Beatmatching Profesional
|
||||
- [ ] **Grid alignment** — alinear warp grids con precisión de ±1 ms
|
||||
- [ ] **Phrase-level sync** — asegurar que los cambios de frase ocurran en múltiplos de 8 compases
|
||||
- [ ] **Tempo ramping** — si los BPMs difieren más de 3%, aplicar ramp gradual durante la mezcla
|
||||
- [ ] **Downbeat alignment** — el downbeat del track entrante cae exactamente en el downbeat del saliente
|
||||
- [ ] **Drift compensation** — compensar el drift de tempo si los tracks tienen tempo fluctuante
|
||||
|
||||
### 5.3 Técnicas de Mezcla Implementadas
|
||||
- [ ] **EQ transition (Bass swap)** — quitar bajos del saliente, subir bajos del entrante en 8 bars
|
||||
- [ ] **Filter crossfade** — low-pass que se cierra en el saliente mientras se abre en el entrante
|
||||
- [ ] **Volume crossfade** — curva S de 16-32 bars entre los dos tracks
|
||||
- [ ] **Acapella moment** — desactivar instrumentos del saliente, dejar solo vocal mientras sube el entrante
|
||||
- [ ] **Loop-in technique** — loopear 4 bars del saliente mientras el entrante se estabiliza
|
||||
- [ ] **Drop-to-drop transition** — ambos tracks en el drop simultáneamente por 8 bars, luego salida
|
||||
- [ ] **Breakdown blend** — salida en breakdown del saliente, entrada en breakdown del entrante
|
||||
- [ ] **Spinback exit** — efecto de parada brusca seguido de entrada del nuevo track
|
||||
- [ ] **Echo exit** — el saliente sale con delay doblado y pitch shifting lento
|
||||
|
||||
### 5.4 Automatización de Efectos en Transición
|
||||
- [ ] **Reverb tail extension** — alargar el reverb del saliente para suavizar la salida
|
||||
- [ ] **Filter automation** — HP filter sube en el saliente, se abre en el entrante
|
||||
- [ ] **Flanger/phaser sweep** — sweep de efecto de modulación durante los 4 bars de transición
|
||||
- [ ] **White noise sweep** — ruido blanco filtrado que sube en el buildup y baja en el drop
|
||||
- [ ] **Reverb gate clap** — clap gateado que actúa como puente entre los dos tracks
|
||||
|
||||
### 5.5 Mashup y Mezcla Creativa
|
||||
- [ ] **Vocal steal** — tomar el vocal loop de Track A y colocarlo sobre el instrumental de Track B
|
||||
- [ ] **Percussion layer** — sumar el top loop de Track A a la batería de Track B por 8 bars
|
||||
- [ ] **Bass substitution** — reemplazar el bass del Track A con el del Track B durante la transición
|
||||
- [ ] **Counter-melody blend** — sumar la melodía de Track A como contrapunto de Track B
|
||||
- [ ] **Energy booster** — si el Track B tiene menos energía, temporalmente sumar samples de impacto
|
||||
|
||||
---
|
||||
|
||||
## FASE 6 — Set Planning e Inteligencia de Flujo
|
||||
> _Prioridad: ALTA · Estimado: 4-5 semanas_
|
||||
|
||||
### 6.1 Arquitectura del Set
|
||||
- [ ] **Set duration planning** — dado duración total (30/60/90/120 min), planear cantidad de tracks y transiciones
|
||||
- [ ] **Energy arc model** — warm-up (20%) → build (30%) → peak (30%) → comedown (20%)
|
||||
- [ ] **BPM progression curve** — ramp de BPM configurable, ej: 122 → 130 → 128 para cierre
|
||||
- [ ] **Key journey** — progresión harmónica a través del set usando Camelot Wheel
|
||||
- [ ] **Genre morphing** — transición suave de sub-géneros: deep house → tech house → techno → industrial
|
||||
|
||||
### 6.2 Generación de Tracklist
|
||||
- [ ] **Opener selection** — tracks de apertura con intro largo, minimalistas, poco frecuente en sets
|
||||
- [ ] **Peak hour tracks** — tracks más intensos reservados para la hora de mayor energía
|
||||
- [ ] **Closer track** — track de cierre con outro largo, emotivo o minimalista
|
||||
- [ ] **Surprise track placement** — posicionar tracks "inesperados" (diferente BPM, key, género) en puntos clave
|
||||
- [ ] **Diversity enforcement** — no repetir mismo artista, mismo pack de samples o misma key en 3 tracks seguidos
|
||||
|
||||
### 6.3 Gestión de Canciones Generadas
|
||||
- [ ] **Song catalog** — base de datos de todos los tracks generados con metadata completa
|
||||
- [ ] **Playability score** — puntuar cada track por cuán mezclable es (intro/outro length, LUFS, key)
|
||||
- [ ] **Set history** — registrar qué tracks se tocaron en qué sets para no repetir
|
||||
- [ ] **Usage stats** — cuántas veces se tocó cada track, temperatura del hit
|
||||
- [ ] **Tagging system** — tags de estado: draft, mix-ready, vetted, retired
|
||||
|
||||
### 6.4 Flujo de Noche Dinámica
|
||||
- [ ] **Crowd response adaptation** — ajustar la energía planeada basado en feedback del operador
|
||||
- [ ] **Emergency track pool** — banco de tracks de relleno por si hay problemas técnicos
|
||||
- [ ] **Mood pivot** — si la energía del set no está funcionando, sugerir pivot de mood
|
||||
- [ ] **Timing buffer** — mantener siempre 2-3 tracks listos de antemano para mezcla inmediata
|
||||
- [ ] **Live override** — el operador puede insertar un track manual y el sistema replanning el resto
|
||||
|
||||
### 6.5 Generación de Variantes por Función
|
||||
- [ ] **Dub mix** — versión con menos elementos para usar durante mezclas (sin melodía principal)
|
||||
- [ ] **DJ Tool** — track sin intro ni melodía, solo ritmo y textura para mezclar con otro track
|
||||
- [ ] **Club edit** — versión más corta del track (5-6 min vs 7+ min) para sets con tiempo limitado
|
||||
- [ ] **Radio edit** — versión de 3.5 min con fade-in y fade-out, sin intro largo
|
||||
- [ ] **Extended mix** — versión con intro/outro de 64 bars cada uno, para mezcla profesional
|
||||
|
||||
---
|
||||
|
||||
## FASE 7 — Generación Musical Procedural
|
||||
> _Prioridad: MEDIA-ALTA · Estimado: 6-8 semanas_
|
||||
|
||||
### 7.1 Síntesis de Melodías
|
||||
- [ ] **Scale-aware melody** — generar melodías que respeten la escala detectada (mayor, menor, dórico, frigio)
|
||||
- [ ] **Interval engine** — generar intervalos musicalmente interesantes (3ras, 5tas, 6tas), no solo secuencias lineales
|
||||
- [ ] **Phrase structure** — melodías de 2/4 bars con pregunta (bars 1-2) y respuesta (bars 3-4)
|
||||
- [ ] **Tension/resolution** — usar la 7ª como nota de tensión, resolver a la 1ª o 5ª
|
||||
- [ ] **Motif engine** — crear un motivo de 2-3 notas y repetirlo con variaciones a lo largo del track
|
||||
- [ ] **Counter-melody** — generar una contra-melodía que complementa la principal
|
||||
- [ ] **Ascending/descending lines** — detectar si el mood pide melodía ascendente (buildup) o descendente (breakdown)
|
||||
|
||||
### 7.2 Progresiones de Acordes
|
||||
- [ ] **Genre-specific chord library** — banco de progresiones por género (house, techno, trance, dnb)
|
||||
- [ ] **Function-aware chords** — I–IV–V–I (tonal), ii–V–I (jazz), i–VII–VI–VII (modal techno)
|
||||
- [ ] **Chord voicing** — voicings distintos por registro (close voicing en graves, open en agudos)
|
||||
- [ ] **Inversions** — usar inversiones de acordes para crear smooth voice leading entre acordes
|
||||
- [ ] **Pedal point** — nota pedal sostenida en el bass mientras los acordes cambian arriba
|
||||
- [ ] **Suspended chords** — usar sus2 y sus4 para crear tensión sin disonancia abierta
|
||||
- [ ] **Modal interchange** — préstamo de acordes de modos paralelos para color emocional
|
||||
|
||||
### 7.3 Líneas de Bajo Generadas
|
||||
- [ ] **Root note bass** — línea de bajo sobre las raíces de los acordes, rítmica y sincopada
|
||||
- [ ] **Walking bass** — línea de bajo que se mueve por grados de escala hacia cada acorde
|
||||
- [ ] **Acid bass pattern** — patrón tipo TB-303 con slides, accents y rests aleatorios dentro de escala
|
||||
- [ ] **Sub + Mid split** — separar el sub (frecuencias <80Hz) del mid-bass (80-250Hz) para procesamiento distinto
|
||||
- [ ] **Octave doubling** — doblar la línea de bajo una octava arriba para cuerpo y definición
|
||||
|
||||
### 7.4 Síntesis de Batería
|
||||
- [ ] **Kick synthesis** — generar kicks sintéticos con seno + click + pitch envelope (estilo TR-909)
|
||||
- [ ] **Snare synthesis** — ruido + tonal con parámetros de color, "crack" y "body"
|
||||
- [ ] **Hat synthesis** — ruido filtrado con envelope de decay muy corto, variaciones de apertura
|
||||
- [ ] **Clap layering** — múltiples ruidos cortos desfasados levemente para clap orgánico
|
||||
- [ ] **Transient design** — ajustar por separado el ataque y el "cuerpo" de cada drum hit
|
||||
|
||||
### 7.5 Texturas y Atmósferas Generativas
|
||||
- [ ] **Drone generation** — generar un drone en la tónica del track para dar sustento armónico
|
||||
- [ ] **Granular texture** — usar síntesis granular sobre un sample para crear texturas únicas
|
||||
- [ ] **Noise color selection** — blanco, rosado o marrón según el mood y la sección del track
|
||||
- [ ] **Stochastic modulation** — parámetros de synth que cambian aleatoriamente dentro de un rango
|
||||
- [ ] **Evolving pad** — pad que cambia lentamente de carácter a lo largo del track usando automación
|
||||
|
||||
---
|
||||
|
||||
## FASE 8 — Mastering Automático de Nivel Label
|
||||
> _Prioridad: MEDIA · Estimado: 4-5 semanas_
|
||||
|
||||
### 8.1 Target Loudness por Destino
|
||||
- [ ] **Streaming master** — -14 LUFS integrated, -1 dBFS true peak (estándar Spotify/Apple)
|
||||
- [ ] **Club master** — -6 LUFS integrated, -0.3 dBFS true peak (para sistemas PA)
|
||||
- [ ] **Broadcast master** — -23 LUFS integrated (EBU R128/ATSC A/85)
|
||||
- [ ] **Vinyl master** — limitado en sub-bass, fase mono, -12 LUFS (limitaciones físicas del vinilo)
|
||||
- [ ] **DJ DJ USB** — -9 LUFS, formato WAV 24bit para Pioneer CDJ/XDJ
|
||||
|
||||
### 8.2 Cadena de Mastering
|
||||
- [ ] **EQ de mastering** — corrección tonal amplia: leve boost de aire, corrección de resonancias
|
||||
- [ ] **Mid-side EQ** — expandir el side, comprimir el mid para imagen más profesional
|
||||
- [ ] **Multi-band compression** — 3-4 bandas de compresión suave para control de dinámica por rango
|
||||
- [ ] **Stereo enhancer** — ampliar levemente el mid-high para más espacio sin afectar el sub
|
||||
- [ ] **Tape emulation** — saturación de cinta leve en el master para calidez analógica
|
||||
- [ ] **Limiting** — limiting con lookahead de 2-8ms, attack rápido, release configurado al BPM
|
||||
- [ ] **True peak limiting** — segundo limiter post-master para garantizar true peak dentro del target
|
||||
|
||||
### 8.3 Análisis y QC del Master
|
||||
- [ ] **Loudness report** — integrated LUFS, momentary LUFS max, LRA (loudness range), true peak
|
||||
- [ ] **Spectral balance report** — gráfico comparando la distribución espectral vs referencia comercial
|
||||
- [ ] **Phase correlation** — verificar que la correlación estéreo sea positiva (>0.5) para compatibilidad mono
|
||||
- [ ] **Clipping check** — escanear el master en busca de clips o inter-sample peaks
|
||||
- [ ] **A/B comparison protocol** — comparar el master vs referencia con ganancia compensada (mismo LUFS)
|
||||
|
||||
### 8.4 Dithering y Formato Final
|
||||
- [ ] **Dithering** — aplicar dithering TPDF al convertir de 32-bit float a 16/24-bit PCM
|
||||
- [ ] **Format conversion** — WAV 24bit/48kHz (producción), WAV 16bit/44.1kHz (CD), FLAC (archivo)
|
||||
- [ ] **MP3 encoding** — export MP3 320kbps para uso en software DJ (CBR, joint stereo)
|
||||
- [ ] **Metadata embedding** — BPM, key, genre, ISRC, album art en los metadatos del archivo final
|
||||
- [ ] **File naming convention** — `[artist]_[title]_[bpm]_[key]_[version].[ext]` automático
|
||||
|
||||
### 8.5 Revisión por Ia Antes del Master
|
||||
- [ ] **Pre-master checklist** — verificar que el mix cumple con los criterios antes de masterizar
|
||||
- [ ] **Headroom verification** — el mix no supera -6 dBFS antes de entrar al master chain
|
||||
- [ ] **Low-end mono check** — confirmar que el sub es mono y el bass no supera el kick en volumen
|
||||
- [ ] **Reverb tail check** — que no haya colas de reverb que superen el tempo al final de las frases
|
||||
- [ ] **Dropout detection** — detectar silencios inesperados o glitches en el audio antes de masterizar
|
||||
|
||||
---
|
||||
|
||||
## FASE 9 — Colaboración, Versionado y Producción en Equipo
|
||||
> _Prioridad: MEDIA · Estimado: 4-6 semanas_
|
||||
|
||||
### 9.1 Versionado de Sesiones
|
||||
- [ ] **Version history** — cada sesión generada se guarda con timestamp y metadata completa
|
||||
- [ ] **Named versions** — versiones con nombre: v1_rough_mix, v2_with_drops, v3_final
|
||||
- [ ] **Diff between versions** — mostrar qué cambió entre dos versiones (BPM, key, samples usados)
|
||||
- [ ] **Rollback** — volver a cualquier versión anterior con un comando
|
||||
- [ ] **Branch system** — crear variantes paralelas de un track sin sobrescribir el original
|
||||
|
||||
### 9.2 Documentación Musical Automática
|
||||
- [ ] **Production notes** — exportar documento con todos los samples usados, BPM, key, settings
|
||||
- [ ] **Sample clearance report** — marcar qué samples son de librerías royalty-free y cuáles no
|
||||
- [ ] **Arrangement timeline** — exportar un diagrama de la estructura del track (intro, verse, drop, etc.)
|
||||
- [ ] **Plugin settings export** — guardar todos los parámetros de los devices de Ableton usados
|
||||
- [ ] **Collaboration template** — exportar el proyecto en formato que otro productor pueda retomar
|
||||
|
||||
### 9.3 Gestión de Sample Library
|
||||
- [ ] **Sample usage tracking** — registrar qué samples se usan en qué tracks
|
||||
- [ ] **Overused sample detection** — alertar si el mismo sample aparece en más de 3 tracks del mismo período
|
||||
- [ ] **Library gap analysis** — detectar qué categorías de samples son escasas en la librería
|
||||
- [ ] **Sample rating system** — votar samples (1-5 estrellas), excluir los de baja calidad de la selección
|
||||
- [ ] **Pack organization** — organizar samples por "pack" (colección de origen) para coherencia tonal
|
||||
|
||||
### 9.4 Exportación y Distribución
|
||||
- [ ] **Stem export automático** — exportar cada bus como archivo separado (drums, bass, music, vocal, fx)
|
||||
- [ ] **Stem naming convention** — nombres con rol y número de proyecto incluido
|
||||
- [ ] **ZIP release package** — empaquetar master, stems, artwork y notes en un ZIP listo para distribuir
|
||||
- [ ] **Streaming metadata** — metadata en formato compatible con DistroKid/TuneCore/CD Baby
|
||||
- [ ] **Cover art generation** — generar artwork minimalista basado en género/mood (integración DALL-E o similar)
|
||||
|
||||
### 9.5 Retroalimentación y Aprendizaje
|
||||
- [ ] **A/B testing de tracks generados** — comparar dos versiones y registrar cuál se prefiere
|
||||
- [ ] **Production log** — registro de decisiones creativas tomadas por el sistema con justificación
|
||||
- [ ] **Error pattern learning** — registrar qué parámetros produjeron resultados malos y evitarlos
|
||||
- [ ] **Style evolution tracking** — documentar cómo evoluciona el "estilo" del sistema a lo largo del tiempo
|
||||
- [ ] **External feedback integration** — formulario para que el DJ/productor califica el resultado
|
||||
|
||||
---
|
||||
|
||||
## FASE 10 — DJ Autónomo Completo
|
||||
> _Prioridad: MEDIA-BAJA · Estimado: 8-12 semanas_
|
||||
|
||||
Esta es la fase final: el sistema es capaz de planear, generar, mezclar y performar un set completo de forma completamente autónoma, con mínima intervención humana.
|
||||
|
||||
### 10.1 Generación de Set Completo End-to-End
|
||||
- [ ] **One-command set** — `generate_set(duration=60, genre='techno', mood='dark')` produce un set completo
|
||||
- [ ] **Coherent sound palette** — todos los tracks del set comparten elementos sonoros para coherencia
|
||||
- [ ] **Progression narrative** — el set cuenta una "historia" musical de apertura hasta el tema emocional
|
||||
- [ ] **Auto-transition rendering** — todas las transiciones pre-renderizadas y listas para playback
|
||||
- [ ] **Continuous mix export** — exportar el set completo como un archivo de audio sin cortes
|
||||
|
||||
### 10.2 Performance en Tiempo Real
|
||||
- [ ] **Live generation** — generar el próximo track mientras el actual está siendo tocado
|
||||
- [ ] **Real-time transition adjustment** — ajustar parámetros de transición basado en lo que está sonando
|
||||
- [ ] **Hot cue system** — colocar hot cues automáticamente en los puntos de mezcla óptimos
|
||||
- [ ] **Loop juggling AI** — el sistema decide cuándo loopear, cuándo romper el loop para máximo impacto
|
||||
- [ ] **FX performance** — disparar efectos en momentos clave (reverb throw, filter sweep) automáticamente
|
||||
|
||||
### 10.3 Respuesta a Contexto
|
||||
- [ ] **Time-of-night awareness** — detectar por reloj si es apertura, peak o cierre y adaptar la energía
|
||||
- [ ] **Venue size adaptation** — configurar para cuarto pequeño (íntimo, técnico) vs festival (más épico)
|
||||
- [ ] **Genre request handling** — el operador pide "más oscuro", "más rápido", "más groovy" en lenguaje natural
|
||||
- [ ] **Emergency handling** — si un track no carga o falla, el sistema selecciona un reemplazo en <1 segundo
|
||||
- [ ] **BPM tempo lock** — nunca salirse de un rango de BPM configurado aunque la selección lo sugiera
|
||||
|
||||
### 10.4 Inteligencia Emocional Musical
|
||||
- [ ] **Mood lexicon** — vocabulario de moods con sus características técnicas (dark = menor, lento, menos brillo)
|
||||
- [ ] **Energy trajectory** — predecir cómo va a evolucionar la energía de los próximos 20 minutos
|
||||
- [ ] **Listener journey modeling** — modelar la experiencia del oyente como una narrativa con arcos
|
||||
- [ ] **Surprise injection** — agregar momentos inesperados cada 20 minutos para mantener atención
|
||||
- [ ] **Emotional contrast** — garantizar contrastes de intensidad para que el peak moment sea más impactante
|
||||
|
||||
### 10.5 Aprendizaje Continuo
|
||||
- [ ] **Session reinforcement learning** — cada set mejora el planeamiento del siguiente
|
||||
- [ ] **Style drift detection** — detectar si el sistema tiende a repetir los mismos patrones y corrección automática
|
||||
- [ ] **Trend awareness** — analizar tracks nuevos periódicamente para mantenerse al día con el sonido actual
|
||||
- [ ] **Personal style refinement** — refinar el "DNA sonoro" del DJ basado en feedback acumulado
|
||||
- [ ] **Cross-genre inspiration** — ocasionalmente tomar elementos de géneros no habituales para innovar
|
||||
|
||||
---
|
||||
|
||||
## 🚀 Quick Wins (valor inmediato, 1-3 días cada uno)
|
||||
|
||||
| # | Feature | Fase | Impacto | Esfuerzo |
|
||||
|---|---|---|---|---|
|
||||
| 1 | **Side-chain kick → bass** | 1.4 | 🔥🔥🔥 | Bajo |
|
||||
| 2 | **Intro/outro de 32 bars** | 2.1 | 🔥🔥🔥 | Bajo |
|
||||
| 3 | **LUFS normalization por track** | 1.1 | 🔥🔥🔥 | Bajo |
|
||||
| 4 | **HP filter automático en intro** | 3.6 | 🔥🔥 | Bajo |
|
||||
| 5 | **Camelot Wheel key compatibility** | 5.1 | 🔥🔥 | Bajo |
|
||||
| 6 | **Crash on first beat of drop** | 2.3 | 🔥🔥 | Bajo |
|
||||
| 7 | **BPM y Key en metadata del archivo** | 8.4 | 🔥 | Bajo |
|
||||
| 8 | **Snare roll en buildup (4 bars)** | 2.3 | 🔥🔥 | Bajo |
|
||||
| 9 | **Reverb tail al salir del breakdown** | 3.1 | 🔥🔥 | Medio |
|
||||
| 10 | **Stereo mono abajo de 200Hz** | 3.5 | 🔥🔥 | Bajo |
|
||||
|
||||
---
|
||||
|
||||
## 💡 Criterio de "DJ Profesional" — Checklist de Aceptación
|
||||
|
||||
Un sistema MCP alcanza nivel DJ profesional cuando puede superar todos estos criterios:
|
||||
|
||||
### Técnicos
|
||||
- [ ] El LUFS integrado de cada track está entre -9 y -8 dBFS (nivel club)
|
||||
- [ ] Nunca hay clipping ni distorsión no intencional en ningún track
|
||||
- [ ] El sub-bass es mono en todos los tracks generados
|
||||
- [ ] El side-chain kick→bass está funcionando y se puede escuchar claramente
|
||||
- [ ] Todas las transiciones entre tracks son musicalmente coherentes
|
||||
|
||||
### Estructurales
|
||||
- [ ] Cada track tiene al menos 32 bars de intro mezclable
|
||||
- [ ] Cada track tiene al menos 32 bars de outro mezclable
|
||||
- [ ] El drop tiene más energía que cualquier sección previa
|
||||
- [ ] El breakdown es notablemente más tranquilo que el drop
|
||||
- [ ] El buildup crea anticipación audible antes del drop
|
||||
|
||||
### DJ Performance
|
||||
- [ ] El sistema puede mezclar dos tracks en menos de 16 bars de superposición
|
||||
- [ ] El key matching garantiza que los dos tracks suenan harmónicos juntos
|
||||
- [ ] Un set de 60 minutos mantiene un arco de energía coherente
|
||||
- [ ] No se repite el mismo sample prominente dentro del mismo set
|
||||
- [ ] El set se puede tocar en una pista sin vergüenza
|
||||
|
||||
### Emocional
|
||||
- [ ] Hay un "momento" memorable en cada track (un riff, un drop, un silencio)
|
||||
- [ ] El set tiene un "peak moment" claramente identificable
|
||||
- [ ] La música crea una respuesta física (ganas de mover los pies)
|
||||
- [ ] Hay coherencia de mood aunque varíe la energía
|
||||
- [ ] El set cuenta una historia que tiene inicio, clímax y cierre
|
||||
469
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/role_matcher.py
Normal file
469
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/role_matcher.py
Normal file
@@ -0,0 +1,469 @@
|
||||
"""
|
||||
role_matcher.py - Phase 4: Role validation and sample matching utilities
|
||||
|
||||
This module provides enhanced role matching for sample selection with:
|
||||
- Role validation based on audio characteristics
|
||||
- Aggressive sample detection and filtering
|
||||
- Logging of matching decisions
|
||||
- Integration with reference_listener and sample_selector
|
||||
"""
|
||||
|
||||
import logging
|
||||
from typing import Any, Dict, List, Optional
|
||||
|
||||
logger = logging.getLogger("RoleMatcher")
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# CONSTANTS
|
||||
# ============================================================================
|
||||
|
||||
# Valid roles for sample matching with their expected characteristics
|
||||
VALID_ROLES = {
|
||||
# One-shot drums
|
||||
"kick": {"max_duration": 2.0, "min_onset": 0.3, "is_loop": False, "bus": "drums"},
|
||||
"snare": {"max_duration": 2.0, "min_onset": 0.25, "is_loop": False, "bus": "drums"},
|
||||
"hat": {"max_duration": 1.5, "min_onset": 0.2, "is_loop": False, "bus": "drums"},
|
||||
"clap": {"max_duration": 2.0, "min_onset": 0.25, "is_loop": False, "bus": "drums"},
|
||||
"ride": {"max_duration": 3.0, "min_onset": 0.15, "is_loop": False, "bus": "drums"},
|
||||
"perc": {"max_duration": 2.5, "min_onset": 0.2, "is_loop": False, "bus": "drums"},
|
||||
# Loops
|
||||
"bass_loop": {"min_duration": 2.0, "max_duration": 16.0, "is_loop": True, "bus": "bass"},
|
||||
"perc_loop": {"min_duration": 2.0, "max_duration": 16.0, "is_loop": True, "bus": "drums"},
|
||||
"top_loop": {"min_duration": 2.0, "max_duration": 16.0, "is_loop": True, "bus": "drums"},
|
||||
"synth_loop": {"min_duration": 2.0, "max_duration": 16.0, "is_loop": True, "bus": "music"},
|
||||
"vocal_loop": {"min_duration": 2.0, "max_duration": 16.0, "is_loop": True, "bus": "vocal"},
|
||||
# FX
|
||||
"crash_fx": {"max_duration": 4.0, "is_loop": False, "bus": "fx"},
|
||||
"fill_fx": {"max_duration": 8.0, "is_loop": False, "bus": "fx"},
|
||||
"snare_roll": {"max_duration": 8.0, "is_loop": False, "bus": "drums"},
|
||||
"atmos_fx": {"min_duration": 4.0, "is_loop": True, "bus": "fx"},
|
||||
"vocal_shot": {"max_duration": 3.0, "is_loop": False, "bus": "vocal"},
|
||||
# Resample layers
|
||||
"resample_reverse": {"is_loop": False, "bus": "fx"},
|
||||
"resample_riser": {"is_loop": False, "bus": "fx"},
|
||||
"resample_downlifter": {"is_loop": False, "bus": "fx"},
|
||||
"resample_stutter": {"is_loop": False, "bus": "vocal"},
|
||||
}
|
||||
|
||||
# Keywords that indicate aggressive/hard samples that may be misclassified
|
||||
AGGRESSIVE_KEYWORDS = {
|
||||
# Very aggressive kick patterns
|
||||
"hard", "distorted", "industrial", "slam", "punch", "brutal",
|
||||
# Potentially misclassified
|
||||
"subdrop", "impact", "explosion", "destroy",
|
||||
}
|
||||
|
||||
# Keywords that are acceptable for aggressive genres
|
||||
GENRE_APPROPRIATE_AGGRESSIVE = {
|
||||
"industrial-techno", "hard-techno", "raw-techno", "psytrance", "dark-techno"
|
||||
}
|
||||
|
||||
# Role aliases for flexible matching
|
||||
ROLE_ALIASES = {
|
||||
"kick": ["kick", "bd", "bassdrum", "bass_drum"],
|
||||
"snare": ["snare", "sd", "snr"],
|
||||
"clap": ["clap", "cp", "handclap"],
|
||||
"hat": ["hat", "hihat", "hi_hat", "hhat", "closed_hat", "hat_closed"],
|
||||
"hat_open": ["open_hat", "hat_open", "ohat", "openhihat"],
|
||||
"ride": ["ride", "rd", "cymbal"],
|
||||
"perc": ["perc", "percussion", "percs"],
|
||||
"bass_loop": ["bass_loop", "bassloop", "bass loop", "sub_bass"],
|
||||
"perc_loop": ["perc_loop", "percloop", "percussion loop", "perc loop"],
|
||||
"top_loop": ["top_loop", "toploop", "top loop", "full_drum"],
|
||||
"synth_loop": ["synth_loop", "synthloop", "synth loop", "chord_loop", "stab"],
|
||||
"vocal_loop": ["vocal_loop", "vocalloop", "vocal loop", "vox_loop", "vox"],
|
||||
"crash_fx": ["crash", "crash_fx", "crashfx", "impact_fx"],
|
||||
"fill_fx": ["fill", "fill_fx", "fillfx", "tom_fill", "transition"],
|
||||
"snare_roll": ["snare_roll", "snareroll", "snare roll", "snr_roll"],
|
||||
"atmos_fx": ["atmos", "atmos_fx", "atmosfx", "drone", "pad_fx"],
|
||||
"vocal_shot": ["vocal_shot", "vocalshot", "vocal shot", "vocal_one_shot"],
|
||||
}
|
||||
|
||||
# Minimum score thresholds for role matching
|
||||
ROLE_SCORE_THRESHOLDS = {
|
||||
"kick": 0.35,
|
||||
"snare": 0.32,
|
||||
"hat": 0.30,
|
||||
"clap": 0.32,
|
||||
"bass_loop": 0.38,
|
||||
"perc_loop": 0.35,
|
||||
"top_loop": 0.35,
|
||||
"synth_loop": 0.36,
|
||||
"vocal_loop": 0.38,
|
||||
"crash_fx": 0.30,
|
||||
"fill_fx": 0.32,
|
||||
"snare_roll": 0.30,
|
||||
"atmos_fx": 0.32,
|
||||
"vocal_shot": 0.34,
|
||||
}
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# VALIDATION FUNCTIONS
|
||||
# ============================================================================
|
||||
|
||||
def validate_role_for_sample(
|
||||
role: str,
|
||||
sample_data: Dict[str, Any],
|
||||
genre: Optional[str] = None,
|
||||
) -> Dict[str, Any]:
|
||||
"""
|
||||
Validates if a sample is appropriate for a given role.
|
||||
|
||||
Args:
|
||||
role: The role to validate for (e.g., 'kick', 'bass_loop')
|
||||
sample_data: Sample metadata with keys like 'duration', 'onset_mean', 'file_name', 'rms_mean'
|
||||
genre: Optional genre for context-aware aggressive sample handling
|
||||
|
||||
Returns:
|
||||
Dict with keys:
|
||||
- 'valid' (bool): Whether the sample passes validation
|
||||
- 'score' (float): Raw validation score (0.0-1.0)
|
||||
- 'warnings' (list): List of warning messages
|
||||
- 'adjusted_score' (float): Score after penalties
|
||||
"""
|
||||
if role not in VALID_ROLES:
|
||||
return {"valid": True, "score": 0.5, "warnings": [f"Unknown role: {role}"], "adjusted_score": 0.5}
|
||||
|
||||
role_config = VALID_ROLES[role]
|
||||
warnings: List[str] = []
|
||||
score = 1.0
|
||||
|
||||
duration = float(sample_data.get("duration", 0.0) or 0.0)
|
||||
onset = float(sample_data.get("onset_mean", 0.0) or 0.0)
|
||||
file_name = str(sample_data.get("file_name", "") or "").lower()
|
||||
rms = float(sample_data.get("rms_mean", 0.0) or 0.0)
|
||||
|
||||
# Duration validation
|
||||
if role_config.get("is_loop"):
|
||||
min_dur = role_config.get("min_duration", 2.0)
|
||||
max_dur = role_config.get("max_duration", 16.0)
|
||||
if duration < min_dur:
|
||||
warnings.append(f"Duration {duration:.1f}s too short for loop role (min {min_dur}s)")
|
||||
score *= 0.7
|
||||
elif max_dur and duration > max_dur:
|
||||
warnings.append(f"Duration {duration:.1f}s too long for role (max {max_dur}s)")
|
||||
score *= 0.85
|
||||
else:
|
||||
max_dur = role_config.get("max_duration", 3.0)
|
||||
if duration > max_dur:
|
||||
warnings.append(f"Duration {duration:.1f}s too long for one-shot role (max {max_dur}s)")
|
||||
score *= 0.75
|
||||
if "loop" in file_name and role in ["kick", "snare", "hat", "clap"]:
|
||||
warnings.append("One-shot role has 'loop' in filename")
|
||||
score *= 0.65
|
||||
|
||||
# Onset validation for percussive elements
|
||||
min_onset = role_config.get("min_onset", 0.0)
|
||||
if min_onset > 0 and onset < min_onset:
|
||||
warnings.append(f"Onset {onset:.2f} below minimum {min_onset:.2f}")
|
||||
score *= 0.85
|
||||
|
||||
# Check for aggressive samples that might be misclassified
|
||||
aggressive_penalty = 1.0
|
||||
is_aggressive_genre = genre and genre.lower() in GENRE_APPROPRIATE_AGGRESSIVE
|
||||
|
||||
for keyword in AGGRESSIVE_KEYWORDS:
|
||||
if keyword in file_name:
|
||||
if not is_aggressive_genre:
|
||||
aggressive_penalty *= 0.88
|
||||
warnings.append(f"Aggressive keyword '{keyword}' found for non-aggressive genre")
|
||||
|
||||
score *= aggressive_penalty
|
||||
|
||||
# RMS validation for certain roles
|
||||
if role in ["kick", "snare", "clap"] and rms > 0.4:
|
||||
warnings.append(f"High RMS {rms:.3f} for one-shot role")
|
||||
score *= 0.9
|
||||
|
||||
adjusted_score = max(0.1, min(1.0, score))
|
||||
|
||||
return {
|
||||
"valid": score >= 0.4,
|
||||
"score": score,
|
||||
"warnings": warnings,
|
||||
"adjusted_score": adjusted_score,
|
||||
}
|
||||
|
||||
|
||||
def resolve_role_from_alias(alias: str) -> Optional[str]:
|
||||
"""
|
||||
Resolves a role name from various aliases.
|
||||
|
||||
Args:
|
||||
alias: A potential role alias (e.g., 'bd', 'hihat', 'bass loop')
|
||||
|
||||
Returns:
|
||||
The canonical role name or None if not found
|
||||
"""
|
||||
alias_lower = alias.lower().strip().replace("-", "_").replace(" ", "_")
|
||||
|
||||
# Direct match
|
||||
if alias_lower in VALID_ROLES:
|
||||
return alias_lower
|
||||
|
||||
# Check aliases
|
||||
for role, aliases in ROLE_ALIASES.items():
|
||||
normalized_aliases = [a.lower().replace("-", "_").replace(" ", "_") for a in aliases]
|
||||
if alias_lower in normalized_aliases:
|
||||
return role
|
||||
|
||||
return None
|
||||
|
||||
|
||||
def get_bus_for_role(role: str) -> str:
|
||||
"""
|
||||
Gets the appropriate bus for a role.
|
||||
|
||||
Args:
|
||||
role: The role name
|
||||
|
||||
Returns:
|
||||
Bus name ('drums', 'bass', 'music', 'vocal', or 'fx')
|
||||
"""
|
||||
if role in VALID_ROLES:
|
||||
return VALID_ROLES[role].get("bus", "music")
|
||||
return "music"
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# LOGGING FUNCTIONS
|
||||
# ============================================================================
|
||||
|
||||
def log_matching_decision(
|
||||
role: str,
|
||||
selected_sample: Optional[Dict[str, Any]],
|
||||
candidates_count: int,
|
||||
final_score: float,
|
||||
validation_result: Optional[Dict[str, Any]] = None,
|
||||
) -> None:
|
||||
"""
|
||||
Logs detailed matching decisions for debugging and analysis.
|
||||
|
||||
Args:
|
||||
role: The role being matched
|
||||
selected_sample: The selected sample dict or None
|
||||
candidates_count: Number of candidates considered
|
||||
final_score: The final matching score
|
||||
validation_result: Optional validation result dict
|
||||
"""
|
||||
if not selected_sample:
|
||||
logger.info(
|
||||
f"[MATCH] Role '{role}': No sample selected (0/{candidates_count} candidates)"
|
||||
)
|
||||
return
|
||||
|
||||
sample_name = selected_sample.get("file_name", "unknown")
|
||||
sample_tempo = selected_sample.get("tempo", 0.0)
|
||||
sample_key = selected_sample.get("key", "N/A")
|
||||
sample_dur = selected_sample.get("duration", 0.0)
|
||||
|
||||
log_parts = [
|
||||
f"[MATCH] Role '{role}':",
|
||||
f"Sample: {sample_name}",
|
||||
f"Score: {final_score:.3f}",
|
||||
f"Tempo: {sample_tempo:.1f}",
|
||||
f"Key: {sample_key}",
|
||||
f"Duration: {sample_dur:.1f}s",
|
||||
f"Candidates: {candidates_count}",
|
||||
]
|
||||
|
||||
if validation_result:
|
||||
warnings = validation_result.get("warnings", [])
|
||||
if warnings:
|
||||
log_parts.append(f"Warnings: {', '.join(warnings)}")
|
||||
log_parts.append(f"Validated: {validation_result.get('valid', True)}")
|
||||
|
||||
logger.info(" | ".join(log_parts))
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# ENHANCEMENT FUNCTIONS
|
||||
# ============================================================================
|
||||
|
||||
def enhance_sample_matching(
|
||||
matches: Dict[str, List[Dict[str, Any]]],
|
||||
reference: Dict[str, Any],
|
||||
genre: Optional[str] = None,
|
||||
) -> Dict[str, List[Dict[str, Any]]]:
|
||||
"""
|
||||
Enhances sample matching results with validation and filtering.
|
||||
|
||||
This function takes raw matches from reference_listener and applies:
|
||||
1. Role validation based on audio characteristics
|
||||
2. Aggressive sample filtering
|
||||
3. Score adjustment based on validation results
|
||||
|
||||
Args:
|
||||
matches: Raw matches from reference_listener (role -> list of sample dicts)
|
||||
reference: Reference track analysis data
|
||||
genre: Target genre for context-aware filtering
|
||||
|
||||
Returns:
|
||||
Enhanced matches with validation scores and filtering applied
|
||||
"""
|
||||
enhanced: Dict[str, List[Dict[str, Any]]] = {}
|
||||
|
||||
for role, candidates in matches.items():
|
||||
if not candidates:
|
||||
enhanced[role] = []
|
||||
continue
|
||||
|
||||
threshold = ROLE_SCORE_THRESHOLDS.get(role, 0.30)
|
||||
enhanced_candidates: List[Dict[str, Any]] = []
|
||||
|
||||
for candidate in candidates:
|
||||
# Create a copy to avoid modifying the original
|
||||
enhanced_candidate = dict(candidate)
|
||||
|
||||
# Validate the sample for this role
|
||||
validation = validate_role_for_sample(role, candidate, genre)
|
||||
enhanced_candidate["validation"] = validation
|
||||
|
||||
# Apply validation penalty to the score
|
||||
original_score = float(candidate.get("score", 0.0))
|
||||
adjusted_score = original_score * validation["adjusted_score"]
|
||||
enhanced_candidate["adjusted_score"] = round(adjusted_score, 6)
|
||||
|
||||
# Filter out samples below threshold
|
||||
if adjusted_score >= threshold:
|
||||
enhanced_candidates.append(enhanced_candidate)
|
||||
else:
|
||||
logger.debug(
|
||||
f"[FILTER] Role '{role}': Filtered out '{candidate.get('file_name', 'unknown')}' "
|
||||
f"(score {adjusted_score:.3f} < threshold {threshold})"
|
||||
)
|
||||
|
||||
# Re-sort by adjusted score
|
||||
enhanced_candidates.sort(key=lambda x: float(x.get("adjusted_score", 0.0)), reverse=True)
|
||||
enhanced[role] = enhanced_candidates
|
||||
|
||||
# Log summary
|
||||
filtered_count = len(candidates) - len(enhanced_candidates)
|
||||
if filtered_count > 0:
|
||||
logger.info(
|
||||
f"[ENHANCE] Role '{role}': {len(enhanced_candidates)}/{len(candidates)} candidates passed validation "
|
||||
f"({filtered_count} filtered out)"
|
||||
)
|
||||
|
||||
return enhanced
|
||||
|
||||
|
||||
def filter_aggressive_samples(
|
||||
candidates: List[Dict[str, Any]],
|
||||
genre: Optional[str] = None,
|
||||
strict: bool = False,
|
||||
) -> List[Dict[str, Any]]:
|
||||
"""
|
||||
Filters out samples with aggressive keywords unless appropriate for the genre.
|
||||
|
||||
Args:
|
||||
candidates: List of sample candidate dicts
|
||||
genre: Target genre
|
||||
strict: If True, apply stricter filtering
|
||||
|
||||
Returns:
|
||||
Filtered list of candidates
|
||||
"""
|
||||
is_aggressive_genre = genre and genre.lower() in GENRE_APPROPRIATE_AGGRESSIVE
|
||||
|
||||
if is_aggressive_genre:
|
||||
# For aggressive genres, don't filter aggressive samples
|
||||
return candidates
|
||||
|
||||
filtered = []
|
||||
for candidate in candidates:
|
||||
file_name = str(candidate.get("file_name", "") or "").lower()
|
||||
aggressive_count = sum(1 for kw in AGGRESSIVE_KEYWORDS if kw in file_name)
|
||||
|
||||
if strict and aggressive_count > 0:
|
||||
continue
|
||||
|
||||
# Apply penalty instead of filtering completely
|
||||
if aggressive_count > 0:
|
||||
penalty = 0.85 ** aggressive_count
|
||||
candidate_copy = dict(candidate)
|
||||
original_score = float(candidate.get("score", 0.0))
|
||||
candidate_copy["score"] = original_score * penalty
|
||||
filtered.append(candidate_copy)
|
||||
else:
|
||||
filtered.append(candidate)
|
||||
|
||||
return filtered
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# INTEGRATION HELPERS
|
||||
# ============================================================================
|
||||
|
||||
def create_enhanced_match_report(
|
||||
role: str,
|
||||
selected_sample: Optional[Dict[str, Any]],
|
||||
all_candidates: List[Dict[str, Any]],
|
||||
validation_result: Optional[Dict[str, Any]] = None,
|
||||
) -> Dict[str, Any]:
|
||||
"""
|
||||
Creates a detailed report for a matching decision.
|
||||
|
||||
Args:
|
||||
role: The role being matched
|
||||
selected_sample: The selected sample
|
||||
all_candidates: All candidates that were considered
|
||||
validation_result: Validation result for the selected sample
|
||||
|
||||
Returns:
|
||||
A dict with detailed matching report
|
||||
"""
|
||||
report = {
|
||||
"role": role,
|
||||
"selected": selected_sample is not None,
|
||||
"candidates_count": len(all_candidates),
|
||||
"threshold": ROLE_SCORE_THRESHOLDS.get(role, 0.30),
|
||||
}
|
||||
|
||||
if selected_sample:
|
||||
report["selected_sample"] = {
|
||||
"name": selected_sample.get("file_name"),
|
||||
"path": selected_sample.get("path"),
|
||||
"score": selected_sample.get("score"),
|
||||
"adjusted_score": selected_sample.get("adjusted_score"),
|
||||
"tempo": selected_sample.get("tempo"),
|
||||
"key": selected_sample.get("key"),
|
||||
"duration": selected_sample.get("duration"),
|
||||
}
|
||||
|
||||
if validation_result:
|
||||
report["validation"] = {
|
||||
"valid": validation_result.get("valid"),
|
||||
"score": validation_result.get("score"),
|
||||
"warnings": validation_result.get("warnings", []),
|
||||
}
|
||||
|
||||
return report
|
||||
|
||||
|
||||
def get_role_info(role: str) -> Dict[str, Any]:
|
||||
"""
|
||||
Gets comprehensive information about a role.
|
||||
|
||||
Args:
|
||||
role: The role name
|
||||
|
||||
Returns:
|
||||
Dict with role information including valid samples count, thresholds, etc.
|
||||
"""
|
||||
if role not in VALID_ROLES:
|
||||
return {"error": f"Unknown role: {role}"}
|
||||
|
||||
config = VALID_ROLES[role]
|
||||
aliases = ROLE_ALIASES.get(role, [])
|
||||
|
||||
return {
|
||||
"role": role,
|
||||
"config": config,
|
||||
"aliases": aliases,
|
||||
"threshold": ROLE_SCORE_THRESHOLDS.get(role, 0.30),
|
||||
"bus": config.get("bus", "music"),
|
||||
"is_loop": config.get("is_loop", False),
|
||||
}
|
||||
308
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/sample_index.py
Normal file
308
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/sample_index.py
Normal file
@@ -0,0 +1,308 @@
|
||||
"""
|
||||
sample_index.py - Índice y búsqueda de samples para AbletonMCP-AI
|
||||
|
||||
Gestiona la librería de samples locales con metadatos extraídos de los nombres.
|
||||
"""
|
||||
|
||||
import json
|
||||
import logging
|
||||
from pathlib import Path
|
||||
from typing import List, Dict, Any, Optional
|
||||
import re
|
||||
|
||||
logger = logging.getLogger("SampleIndex")
|
||||
|
||||
|
||||
class SampleIndex:
|
||||
"""Índice de samples con búsqueda y metadatos"""
|
||||
|
||||
# Categorías por palabras clave
|
||||
CATEGORIES = {
|
||||
'kick': ['kick', 'bd', 'bass drum', 'kick drum'],
|
||||
'snare': ['snare', 'sd', 'snr'],
|
||||
'clap': ['clap', 'clp'],
|
||||
'hat': ['hat', 'hh', 'hihat', 'hi-hat', 'closed hat', 'open hat'],
|
||||
'perc': ['perc', 'percussion', 'conga', 'bongo', 'shaker', 'tamb', 'timb'],
|
||||
'bass': ['bass', 'bassline', 'sub', '808', ' Reese'],
|
||||
'synth': ['synth', 'lead', 'pad', 'arp', 'pluck', 'stab', 'chord'],
|
||||
'vocal': ['vocal', 'vox', 'voice', 'speech', 'talk'],
|
||||
'fx': ['fx', 'effect', 'sweep', 'riser', 'downlifter', 'impact', 'hit'],
|
||||
'loop': ['loop', 'full', 'groove'],
|
||||
}
|
||||
|
||||
def __init__(self, base_dir: str):
|
||||
"""
|
||||
Inicializa el índice de samples
|
||||
|
||||
Args:
|
||||
base_dir: Directorio base donde buscar samples
|
||||
"""
|
||||
self.base_dir = Path(base_dir)
|
||||
self.samples: List[Dict[str, Any]] = []
|
||||
self.index_file = self.base_dir / ".sample_index.json"
|
||||
|
||||
# Cargar o construir índice
|
||||
if self.index_file.exists():
|
||||
self._load_index()
|
||||
else:
|
||||
self._build_index()
|
||||
self._save_index()
|
||||
|
||||
def _build_index(self):
|
||||
"""Construye el índice escaneando el directorio"""
|
||||
logger.info(f"Construyendo índice de samples en: {self.base_dir}")
|
||||
|
||||
extensions = {'.wav', '.aif', '.aiff', '.mp3', '.ogg'}
|
||||
|
||||
for file_path in self.base_dir.rglob('*'):
|
||||
if file_path.suffix.lower() in extensions:
|
||||
sample_info = self._analyze_sample(file_path)
|
||||
self.samples.append(sample_info)
|
||||
|
||||
logger.info(f"Índice construido: {len(self.samples)} samples encontrados")
|
||||
|
||||
def _analyze_sample(self, file_path: Path) -> Dict[str, Any]:
|
||||
"""Analiza un sample y extrae metadatos del nombre"""
|
||||
name = file_path.stem
|
||||
name_lower = name.lower()
|
||||
|
||||
# Determinar categoría
|
||||
category = self._detect_category(name_lower)
|
||||
|
||||
# Extraer key del nombre
|
||||
key = self._extract_key(name)
|
||||
|
||||
# Extraer BPM del nombre
|
||||
bpm = self._extract_bpm(name)
|
||||
|
||||
return {
|
||||
'name': name,
|
||||
'path': str(file_path),
|
||||
'category': category,
|
||||
'key': key,
|
||||
'bpm': bpm,
|
||||
'size': file_path.stat().st_size if file_path.exists() else 0,
|
||||
}
|
||||
|
||||
def _detect_category(self, name: str) -> str:
|
||||
"""Detecta la categoría basada en palabras clave"""
|
||||
for category, keywords in self.CATEGORIES.items():
|
||||
for keyword in keywords:
|
||||
if keyword in name:
|
||||
return category
|
||||
return 'unknown'
|
||||
|
||||
def _extract_key(self, name: str) -> Optional[str]:
|
||||
"""Extrae la tonalidad del nombre del archivo"""
|
||||
# Patrones comunes: "Key A", "in A", "A minor", "Am", "F#m", etc.
|
||||
patterns = [
|
||||
r'[_\s\-]([A-G][#b]?m?)\s*(?:minor|major)?[_\s\-]?',
|
||||
r'[_\s\-]([A-G][#b]?)[_\s\-]',
|
||||
r'\bin\s+([A-G][#b]?m?)\b',
|
||||
r'Key\s+([A-G][#b]?m?)',
|
||||
]
|
||||
|
||||
for pattern in patterns:
|
||||
match = re.search(pattern, name, re.IGNORECASE)
|
||||
if match:
|
||||
key = match.group(1)
|
||||
# Normalizar
|
||||
key = key.replace('b', '#').replace('Db', 'C#').replace('Eb', 'D#')
|
||||
key = key.replace('Gb', 'F#').replace('Ab', 'G#').replace('Bb', 'A#')
|
||||
return key
|
||||
|
||||
return None
|
||||
|
||||
def _extract_bpm(self, name: str) -> Optional[int]:
|
||||
"""Extrae el BPM del nombre del archivo"""
|
||||
# Patrones: "128 BPM", "_128_", "128bpm", etc.
|
||||
patterns = [
|
||||
r'[_\s\-](\d{2,3})\s*BPM',
|
||||
r'[_\s\-](\d{2,3})[_\s\-]',
|
||||
r'(\d{2,3})bpm',
|
||||
]
|
||||
|
||||
for pattern in patterns:
|
||||
match = re.search(pattern, name, re.IGNORECASE)
|
||||
if match:
|
||||
bpm = int(match.group(1))
|
||||
if 60 <= bpm <= 200: # Rango razonable
|
||||
return bpm
|
||||
|
||||
return None
|
||||
|
||||
def _load_index(self):
|
||||
"""Carga el índice desde archivo"""
|
||||
try:
|
||||
with open(self.index_file, 'r') as f:
|
||||
data = json.load(f)
|
||||
self.samples = data.get('samples', [])
|
||||
logger.info(f"Índice cargado: {len(self.samples)} samples")
|
||||
except Exception as e:
|
||||
logger.error(f"Error cargando índice: {e}")
|
||||
self._build_index()
|
||||
|
||||
def _save_index(self):
|
||||
"""Guarda el índice a archivo"""
|
||||
try:
|
||||
with open(self.index_file, 'w') as f:
|
||||
json.dump({
|
||||
'samples': self.samples,
|
||||
'base_dir': str(self.base_dir)
|
||||
}, f, indent=2)
|
||||
logger.info(f"Índice guardado en: {self.index_file}")
|
||||
except Exception as e:
|
||||
logger.error(f"Error guardando índice: {e}")
|
||||
|
||||
def search(self, query: str, category: str = "", limit: int = 10) -> List[Dict[str, Any]]:
|
||||
"""
|
||||
Busca samples por query y/o categoría
|
||||
|
||||
Args:
|
||||
query: Término de búsqueda
|
||||
category: Categoría específica (opcional)
|
||||
limit: Número máximo de resultados
|
||||
|
||||
Returns:
|
||||
Lista de samples que coinciden
|
||||
"""
|
||||
query_lower = query.lower()
|
||||
results = []
|
||||
|
||||
for sample in self.samples:
|
||||
# Filtrar por categoría si se especificó
|
||||
if category and sample['category'] != category.lower():
|
||||
continue
|
||||
|
||||
# Buscar en nombre
|
||||
name = sample['name'].lower()
|
||||
if query_lower in name:
|
||||
# Calcular score de relevancia
|
||||
score = 0
|
||||
if query_lower == sample.get('category', ''):
|
||||
score += 10 # Coincidencia exacta de categoría
|
||||
if query_lower in name.split('_'):
|
||||
score += 5 # Palabra completa
|
||||
if name.startswith(query_lower):
|
||||
score += 3 # Comienza con el término
|
||||
|
||||
results.append((score, sample))
|
||||
|
||||
# Ordenar por score y limitar
|
||||
results.sort(key=lambda x: x[0], reverse=True)
|
||||
return [sample for _, sample in results[:limit]]
|
||||
|
||||
def find_by_key(self, key: str, category: str = "", limit: int = 10) -> List[Dict[str, Any]]:
|
||||
"""Busca samples por tonalidad"""
|
||||
results = []
|
||||
|
||||
for sample in self.samples:
|
||||
if sample.get('key') == key:
|
||||
if not category or sample['category'] == category:
|
||||
results.append(sample)
|
||||
|
||||
return results[:limit]
|
||||
|
||||
def find_by_bpm(self, bpm: int, tolerance: int = 5, limit: int = 10) -> List[Dict[str, Any]]:
|
||||
"""Busca samples por BPM con tolerancia"""
|
||||
results = []
|
||||
|
||||
for sample in self.samples:
|
||||
sample_bpm = sample.get('bpm')
|
||||
if sample_bpm and abs(sample_bpm - bpm) <= tolerance:
|
||||
results.append(sample)
|
||||
|
||||
return results[:limit]
|
||||
|
||||
def get_random_sample(self, category: str = "") -> Optional[Dict[str, Any]]:
|
||||
"""Obtiene un sample aleatorio, opcionalmente filtrado por categoría"""
|
||||
import random
|
||||
|
||||
samples = self.samples
|
||||
if category:
|
||||
samples = [s for s in samples if s['category'] == category]
|
||||
|
||||
return random.choice(samples) if samples else None
|
||||
|
||||
def get_sample_pack(self, genre: str, key: str = "", bpm: int = 0) -> Dict[str, List[Dict]]:
|
||||
"""
|
||||
Obtiene un pack de samples completo para un género
|
||||
|
||||
Args:
|
||||
genre: Género musical
|
||||
key: Tonalidad preferida
|
||||
bpm: BPM preferido
|
||||
|
||||
Returns:
|
||||
Dict con samples organizados por categoría
|
||||
"""
|
||||
pack = {
|
||||
'kick': [],
|
||||
'snare': [],
|
||||
'hat': [],
|
||||
'clap': [],
|
||||
'perc': [],
|
||||
'bass': [],
|
||||
'synth': [],
|
||||
'fx': [],
|
||||
}
|
||||
|
||||
# Seleccionar un sample de cada categoría
|
||||
for category in pack.keys():
|
||||
candidates = [s for s in self.samples if s['category'] == category]
|
||||
|
||||
# Filtrar por key si se especificó
|
||||
if key and candidates:
|
||||
key_matches = [s for s in candidates if s.get('key') == key]
|
||||
if key_matches:
|
||||
candidates = key_matches
|
||||
|
||||
# Filtrar por BPM si se especificó
|
||||
if bpm and candidates:
|
||||
bpm_matches = [s for s in candidates if s.get('bpm')]
|
||||
if bpm_matches:
|
||||
# Ordenar por cercanía al BPM objetivo
|
||||
bpm_matches.sort(key=lambda s: abs(s['bpm'] - bpm))
|
||||
candidates = bpm_matches[:5] # Top 5 más cercanos
|
||||
|
||||
# Seleccionar hasta 3 samples
|
||||
import random
|
||||
if candidates:
|
||||
pack[category] = random.sample(candidates, min(3, len(candidates)))
|
||||
|
||||
return pack
|
||||
|
||||
def refresh(self):
|
||||
"""Reconstruye el índice desde cero"""
|
||||
logger.info("Refrescando índice...")
|
||||
self._build_index()
|
||||
self._save_index()
|
||||
|
||||
|
||||
# Función de utilidad para testing
|
||||
if __name__ == "__main__":
|
||||
import sys
|
||||
|
||||
if len(sys.argv) < 2:
|
||||
print("Uso: python sample_index.py <directorio_de_samples>")
|
||||
sys.exit(1)
|
||||
|
||||
logging.basicConfig(level=logging.INFO)
|
||||
|
||||
index = SampleIndex(sys.argv[1])
|
||||
|
||||
print(f"\nÍndice cargado: {len(index.samples)} samples")
|
||||
print("\nDistribución por categoría:")
|
||||
|
||||
categories = {}
|
||||
for sample in index.samples:
|
||||
cat = sample['category']
|
||||
categories[cat] = categories.get(cat, 0) + 1
|
||||
|
||||
for cat, count in sorted(categories.items(), key=lambda x: -x[1]):
|
||||
print(f" {cat}: {count}")
|
||||
|
||||
# Ejemplo de búsqueda
|
||||
print("\nBúsqueda 'kick':")
|
||||
for s in index.search("kick", limit=5):
|
||||
print(f" - {s['name']} ({s.get('key', '?')}, {s.get('bpm', '?')} BPM)")
|
||||
1087
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/sample_manager.py
Normal file
1087
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/sample_manager.py
Normal file
File diff suppressed because it is too large
Load Diff
2896
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/sample_selector.py
Normal file
2896
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/sample_selector.py
Normal file
File diff suppressed because it is too large
Load Diff
244
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/sample_system_demo.py
Normal file
244
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/sample_system_demo.py
Normal file
@@ -0,0 +1,244 @@
|
||||
"""
|
||||
Demo del Sistema de Gestión de Samples para AbletonMCP-AI
|
||||
|
||||
Este script demuestra las capacidades del sistema completo de samples.
|
||||
"""
|
||||
|
||||
import sys
|
||||
from pathlib import Path
|
||||
sys.path.insert(0, str(Path(__file__).parent))
|
||||
|
||||
from sample_manager import get_manager
|
||||
from sample_selector import get_selector
|
||||
from audio_analyzer import analyze_sample, AudioAnalyzer
|
||||
|
||||
|
||||
def demo_analyzer():
|
||||
"""Demostración del analizador de audio"""
|
||||
print("=" * 60)
|
||||
print("DEMO: Audio Analyzer")
|
||||
print("=" * 60)
|
||||
|
||||
AudioAnalyzer(backend='basic')
|
||||
|
||||
# Analizar un archivo de ejemplo
|
||||
test_file = r"C:\Users\ren\embeddings\all_tracks\BBH - Primer Impacto - Kick 1.wav"
|
||||
|
||||
print(f"\nAnalizando: {Path(test_file).name}")
|
||||
print("-" * 40)
|
||||
|
||||
try:
|
||||
result = analyze_sample(test_file)
|
||||
|
||||
print(f"Tipo detectado: {result['sample_type']}")
|
||||
print(f"BPM: {result.get('bpm') or 'No detectado'}")
|
||||
print(f"Key: {result.get('key') or 'No detectado'}")
|
||||
print(f"Duración: {result['duration']:.3f}s")
|
||||
print(f"Es percusivo: {result['is_percussive']}")
|
||||
print(f"Géneros sugeridos: {', '.join(result['suggested_genres'])}")
|
||||
|
||||
except Exception as e:
|
||||
print(f"Error: {e}")
|
||||
|
||||
print()
|
||||
|
||||
|
||||
def demo_manager():
|
||||
"""Demostración del gestor de samples"""
|
||||
print("=" * 60)
|
||||
print("DEMO: Sample Manager")
|
||||
print("=" * 60)
|
||||
|
||||
manager = get_manager(r"C:\Users\ren\embeddings\all_tracks")
|
||||
|
||||
# Escanear librería
|
||||
print("\nEscaneando librería...")
|
||||
stats = manager.scan_directory()
|
||||
print(f" Samples procesados: {stats['processed']}")
|
||||
print(f" Nuevos: {stats['added']}")
|
||||
print(f" Total en librería: {stats['total_samples']}")
|
||||
|
||||
# Estadísticas
|
||||
print("\nEstadísticas:")
|
||||
stats = manager.get_stats()
|
||||
print(f" Total: {stats['total_samples']} samples")
|
||||
print(f" Tamaño: {stats['total_size'] / (1024**2):.1f} MB")
|
||||
|
||||
if stats['by_category']:
|
||||
print("\n Por categoría:")
|
||||
for cat, count in sorted(stats['by_category'].items(), key=lambda x: -x[1]):
|
||||
print(f" {cat}: {count}")
|
||||
|
||||
if stats['by_key']:
|
||||
print("\n Por key:")
|
||||
for key, count in sorted(stats['by_key'].items(), key=lambda x: -x[1]):
|
||||
print(f" {key}: {count}")
|
||||
|
||||
# Búsquedas
|
||||
print("\nBúsquedas:")
|
||||
print("-" * 40)
|
||||
|
||||
# Buscar kicks
|
||||
kicks = manager.search(sample_type="kick", limit=3)
|
||||
print(f"\nKicks encontrados: {len(kicks)}")
|
||||
for s in kicks:
|
||||
print(f" - {s.name}")
|
||||
|
||||
# Buscar por key
|
||||
g_sharp = manager.search(key="G#m", limit=3)
|
||||
print(f"\nSamples en G#m: {len(g_sharp)}")
|
||||
for s in g_sharp:
|
||||
print(f" - {s.name} ({s.sample_type})")
|
||||
|
||||
# Buscar por BPM
|
||||
bpm_128 = manager.search(bpm=128, bpm_tolerance=5, limit=3)
|
||||
print(f"\nSamples ~128 BPM: {len(bpm_128)}")
|
||||
for s in bpm_128:
|
||||
key_info = f" [{s.key}]" if s.key else ""
|
||||
print(f" - {s.name}{key_info}")
|
||||
|
||||
print()
|
||||
|
||||
|
||||
def demo_selector():
|
||||
"""Demostración del selector inteligente"""
|
||||
print("=" * 60)
|
||||
print("DEMO: Sample Selector")
|
||||
print("=" * 60)
|
||||
|
||||
selector = get_selector()
|
||||
|
||||
# Seleccionar para diferentes géneros
|
||||
genres = ['techno', 'house', 'tech-house']
|
||||
|
||||
for genre in genres:
|
||||
print(f"\n{genre.upper()}:")
|
||||
print("-" * 40)
|
||||
|
||||
group = selector.select_for_genre(genre, key='Am', bpm=128)
|
||||
|
||||
print(f" Key: {group.key} | BPM: {group.bpm}")
|
||||
|
||||
# Drum kit
|
||||
kit = group.drums
|
||||
print("\n Drum Kit:")
|
||||
if kit.kick:
|
||||
print(f" Kick: {kit.kick.name}")
|
||||
if kit.snare:
|
||||
print(f" Snare: {kit.snare.name}")
|
||||
if kit.clap:
|
||||
print(f" Clap: {kit.clap.name}")
|
||||
if kit.hat_closed:
|
||||
print(f" Hat: {kit.hat_closed.name}")
|
||||
|
||||
# Mapeo MIDI
|
||||
mapping = selector.get_midi_mapping_for_kit(kit)
|
||||
print("\n Mapeo MIDI:")
|
||||
for note, info in sorted(mapping['notes'].items())[:4]:
|
||||
if info['sample']:
|
||||
print(f" Note {note}: {info['sample'][:40]}...")
|
||||
|
||||
# Bass
|
||||
if group.bass:
|
||||
print(f"\n Bass ({len(group.bass)}):")
|
||||
for s in group.bass[:2]:
|
||||
key_info = f" [{s.key}]" if s.key else ""
|
||||
print(f" - {s.name}{key_info}")
|
||||
|
||||
# Cambio de key
|
||||
print("\n" + "-" * 40)
|
||||
print("Cambios de Key Sugeridos (desde Am):")
|
||||
changes = ['fifth_up', 'fifth_down', 'relative', 'parallel']
|
||||
for change in changes:
|
||||
new_key = selector.suggest_key_change('Am', change)
|
||||
print(f" {change}: {new_key}")
|
||||
|
||||
print()
|
||||
|
||||
|
||||
def demo_compatibility():
|
||||
"""Demostración de búsqueda de samples compatibles"""
|
||||
print("=" * 60)
|
||||
print("DEMO: Compatibilidad de Samples")
|
||||
print("=" * 60)
|
||||
|
||||
manager = get_manager()
|
||||
selector = get_selector()
|
||||
|
||||
# Encontrar un sample con key para usar de referencia
|
||||
samples_with_key = manager.search(key="G#m", limit=1)
|
||||
|
||||
if samples_with_key:
|
||||
reference = samples_with_key[0]
|
||||
print(f"\nSample de referencia: {reference.name}")
|
||||
print(f" Key: {reference.key} | BPM: {reference.bpm}")
|
||||
|
||||
# Buscar compatibles
|
||||
compatible = selector.find_compatible_samples(reference, max_results=5)
|
||||
|
||||
print("\nSamples compatibles:")
|
||||
print("-" * 40)
|
||||
|
||||
for sample, score in compatible:
|
||||
bar_len = int(score * 20)
|
||||
bar = "█" * bar_len + "░" * (20 - bar_len)
|
||||
print(f" [{bar}] {score:.1%} - {sample.name}")
|
||||
|
||||
print()
|
||||
|
||||
|
||||
def demo_pack_generation():
|
||||
"""Demostración de generación de packs"""
|
||||
print("=" * 60)
|
||||
print("DEMO: Generación de Sample Packs")
|
||||
print("=" * 60)
|
||||
|
||||
manager = get_manager()
|
||||
|
||||
genres = ['techno', 'house', 'deep-house']
|
||||
|
||||
for genre in genres:
|
||||
print(f"\n{genre.upper()} Pack:")
|
||||
print("-" * 40)
|
||||
|
||||
pack = manager.get_pack_for_genre(genre, key='Am', bpm=128)
|
||||
|
||||
total = 0
|
||||
for category, samples in pack.items():
|
||||
if samples:
|
||||
count = len(samples)
|
||||
total += count
|
||||
print(f" {category}: {count}")
|
||||
|
||||
print(f" Total: {total} samples")
|
||||
|
||||
print()
|
||||
|
||||
|
||||
def main():
|
||||
"""Ejecutar todas las demos"""
|
||||
print("\n")
|
||||
print("=" * 60)
|
||||
print(" AbletonMCP-AI Sample System Demo ".center(60))
|
||||
print("=" * 60)
|
||||
print()
|
||||
|
||||
try:
|
||||
demo_analyzer()
|
||||
demo_manager()
|
||||
demo_selector()
|
||||
demo_compatibility()
|
||||
demo_pack_generation()
|
||||
|
||||
print("=" * 60)
|
||||
print("Todas las demos completadas exitosamente!")
|
||||
print("=" * 60)
|
||||
|
||||
except Exception as e:
|
||||
print(f"\nError en demo: {e}")
|
||||
import traceback
|
||||
traceback.print_exc()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
16
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/scan_audio.py
Normal file
16
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/scan_audio.py
Normal file
@@ -0,0 +1,16 @@
|
||||
import sample_manager
|
||||
|
||||
print('Iniciando escaneo de la libreria de samples con analyze_audio=True...')
|
||||
try:
|
||||
path = r'C:\ProgramData\Ableton\Live 12 Suite\Resources\MIDI Remote Scripts\AbletonMCP_AI\librerias\organized_samples'
|
||||
stats = sample_manager.scan_samples(path, analyze_audio=True)
|
||||
p = stats.get('processed', 0)
|
||||
a = stats.get('added', 0)
|
||||
u = stats.get('updated', 0)
|
||||
e = stats.get('errors', 0)
|
||||
print(f'Procesados: {p}')
|
||||
print(f'Agregados: {a}')
|
||||
print(f'Actualizados: {u}')
|
||||
print(f'Errores: {e}')
|
||||
except Exception as e:
|
||||
print('Error:', e)
|
||||
198
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/segment_rag_builder.py
Normal file
198
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/segment_rag_builder.py
Normal file
@@ -0,0 +1,198 @@
|
||||
"""
|
||||
segment_rag_builder.py - Build or refresh the persistent segment-audio index.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import logging
|
||||
from pathlib import Path
|
||||
|
||||
from reference_listener import ReferenceAudioListener, export_segment_rag_manifest, generate_segment_rag_summary, _get_segment_rag_status, _backfill_segment_cache_metadata
|
||||
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
def _default_library_dir() -> Path:
|
||||
return Path(__file__).resolve().parents[2] / "librerias" / "organized_samples"
|
||||
|
||||
|
||||
def main() -> int:
|
||||
parser = argparse.ArgumentParser(description="Build the persistent segment-audio retrieval cache.")
|
||||
parser.add_argument("--library-dir", default=str(_default_library_dir()), help="Audio library directory")
|
||||
parser.add_argument("--roles", nargs="*", default=None, help="Subset of roles to index")
|
||||
parser.add_argument("--max-files", type=int, default=None, help="Optional limit for targeted files")
|
||||
parser.add_argument("--duration-limit", type=float, default=24.0, help="Max seconds per file during indexing")
|
||||
parser.add_argument("--force", action="store_true", help="Rebuild even if persistent segment cache already exists")
|
||||
parser.add_argument("--json", action="store_true", help="Emit full JSON report")
|
||||
parser.add_argument("-v", "--verbose", action="store_true", help="Enable verbose output")
|
||||
parser.add_argument("--offset", type=int, default=0, help="Skip first N files before starting (for chunked indexing)")
|
||||
parser.add_argument("--batch-size", type=int, default=None, help="Process exactly N files then stop (for chunked indexing)")
|
||||
parser.add_argument("--output-manifest", type=str, default=None, help="Path to save full manifest JSON")
|
||||
parser.add_argument("--output-summary", type=str, default=None, help="Path to save summary report")
|
||||
parser.add_argument("--resume", action="store_true", help="Resume from previous run state")
|
||||
parser.add_argument("--export-manifest", type=str, default=None,
|
||||
help="Export candidate manifest to FILE (format: .json or .md)")
|
||||
parser.add_argument("--export-format", type=str, default="json",
|
||||
choices=['json', 'markdown'], help="Manifest export format")
|
||||
parser.add_argument("--status", action="store_true", help="Show current index status without building")
|
||||
parser.add_argument("--backfill-metadata", action="store_true", help="Backfill metadata into existing cache files from indexing state")
|
||||
parser.add_argument("--force-backfill", action="store_true", help="Force backfill even for files that already have metadata")
|
||||
args = parser.parse_args()
|
||||
|
||||
# Configure logging based on verbose flag
|
||||
if args.verbose:
|
||||
logging.basicConfig(level=logging.DEBUG, format='%(levelname)s: %(message)s')
|
||||
else:
|
||||
logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s')
|
||||
|
||||
# Handle --status flag for early exit
|
||||
if args.status:
|
||||
status = _get_segment_rag_status(Path(args.library_dir))
|
||||
|
||||
if args.json:
|
||||
print(json.dumps(status, indent=2, default=str))
|
||||
else:
|
||||
print("=" * 60)
|
||||
print("SEGMENT RAG INDEX STATUS")
|
||||
print("=" * 60)
|
||||
print(f"Cache Directory: {status['cache_dir']}")
|
||||
print(f"Cache Files: {status['cache_files']}")
|
||||
print(f"Total Indexed Segments: {status['total_segments']}")
|
||||
print(f"Status: {status.get('status', 'unknown')}")
|
||||
|
||||
if status.get('role_coverage'):
|
||||
print("\nRole Coverage:")
|
||||
for role, count in sorted(status['role_coverage'].items()):
|
||||
print(f" {role}: {count} segments")
|
||||
|
||||
if status.get('newest_entries'):
|
||||
print(f"\nNewest Entries: {len(status['newest_entries'])} files")
|
||||
for entry in status['newest_entries'][:5]:
|
||||
print(f" - {entry['file_name']} ({entry['segments']} segments)")
|
||||
|
||||
if status.get('oldest_entries'):
|
||||
print(f"\nOldest Entries: {len(status['oldest_entries'])} files")
|
||||
for entry in status['oldest_entries'][:5]:
|
||||
print(f" - {entry['file_name']} ({entry['segments']} segments)")
|
||||
|
||||
return 0
|
||||
|
||||
# Handle --backfill-metadata flag for early exit
|
||||
if args.backfill_metadata:
|
||||
result = _backfill_segment_cache_metadata(Path(args.library_dir), force=args.force_backfill)
|
||||
|
||||
if args.json:
|
||||
print(json.dumps(result, indent=2, default=str))
|
||||
else:
|
||||
print("=" * 60)
|
||||
print("SEGMENT CACHE METADATA BACKFILL")
|
||||
print("=" * 60)
|
||||
print(f"Cache Directory: {result['cache_dir']}")
|
||||
print(f"Cache Files: {result['cache_files']}")
|
||||
print(f"Backfilled: {result['backfilled']}")
|
||||
print(f"Skipped: {result['skipped']}")
|
||||
print(f"Errors: {result['errors']}")
|
||||
print(f"Status: {result.get('status', 'unknown')}")
|
||||
|
||||
return 0
|
||||
|
||||
listener = ReferenceAudioListener(args.library_dir)
|
||||
report = listener.build_segment_rag_index(
|
||||
roles=args.roles,
|
||||
max_files=args.max_files,
|
||||
duration_limit=args.duration_limit,
|
||||
force=args.force,
|
||||
offset=args.offset,
|
||||
batch_size=args.batch_size,
|
||||
resume=args.resume,
|
||||
)
|
||||
|
||||
# Generate enhanced summary
|
||||
summary = generate_segment_rag_summary(report, Path(args.library_dir))
|
||||
|
||||
if args.json:
|
||||
print(json.dumps(summary, indent=2, default=str))
|
||||
else:
|
||||
# Enhanced text output
|
||||
print("=" * 60)
|
||||
print("SEGMENT RAG INDEX COMPLETE")
|
||||
print("=" * 60)
|
||||
print(f"Device: {summary['device']}")
|
||||
print(f"Cache: {summary['segment_index_dir']}")
|
||||
print()
|
||||
print(f"Files: {summary['files_targeted']} targeted")
|
||||
print(f" Built: {summary['built']}")
|
||||
print(f" Reused: {summary['reused']}")
|
||||
print(f" Skipped: {summary['skipped']}")
|
||||
print(f" Errors: {summary['errors']}")
|
||||
print()
|
||||
print(f"Total Segments: {summary['total_segments']}")
|
||||
|
||||
if 'summary_stats' in summary:
|
||||
stats = summary['summary_stats']
|
||||
print(f" Avg per file: {stats['avg_segments_per_file']:.1f}")
|
||||
print(f" Range: {stats['min_segments']} - {stats['max_segments']}")
|
||||
|
||||
if 'role_coverage' in summary:
|
||||
print("\nRole Coverage:")
|
||||
for role in sorted(summary['role_coverage'].keys()):
|
||||
print(f" {role}: {summary['role_coverage'][role]} segments")
|
||||
|
||||
if 'cache_info' in summary:
|
||||
info = summary['cache_info']
|
||||
print(f"\nCache Size: {info['cache_size_mb']} MB")
|
||||
|
||||
if args.offset > 0:
|
||||
print(f"\nOffset: {args.offset}")
|
||||
if args.batch_size is not None:
|
||||
print(f"Batch Size: {args.batch_size}")
|
||||
print(f"Files Remaining: {summary.get('files_remaining', 'unknown')}")
|
||||
|
||||
# Save manifest if requested
|
||||
if args.output_manifest:
|
||||
manifest_path = Path(args.output_manifest)
|
||||
manifest_path.parent.mkdir(parents=True, exist_ok=True)
|
||||
with open(manifest_path, 'w') as f:
|
||||
json.dump({
|
||||
"report": report,
|
||||
"full_manifest": report.get("manifest", []),
|
||||
}, f, indent=2)
|
||||
if not args.json:
|
||||
print(f"\nManifest saved to: {manifest_path}")
|
||||
|
||||
# Save summary if requested
|
||||
if args.output_summary:
|
||||
summary_path = Path(args.output_summary)
|
||||
summary_path.parent.mkdir(parents=True, exist_ok=True)
|
||||
with open(summary_path, 'w') as f:
|
||||
json.dump(summary, f, indent=2, default=str)
|
||||
if not args.json:
|
||||
print(f"Summary saved to: {summary_path}")
|
||||
|
||||
# Export manifest in requested format
|
||||
if args.export_manifest:
|
||||
manifest_path = Path(args.export_manifest)
|
||||
export_format = args.export_format
|
||||
|
||||
# Determine format from extension if not specified
|
||||
if not args.export_format or args.export_format == "json":
|
||||
if manifest_path.suffix == '.md':
|
||||
export_format = 'markdown'
|
||||
else:
|
||||
export_format = 'json'
|
||||
|
||||
export_segment_rag_manifest(
|
||||
report.get('manifest', []),
|
||||
manifest_path,
|
||||
format=export_format
|
||||
)
|
||||
print(f"Manifest exported to: {manifest_path}")
|
||||
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
363
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/self_ai.py
Normal file
363
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/self_ai.py
Normal file
@@ -0,0 +1,363 @@
|
||||
"""
|
||||
self_ai.py - Self-AI y Auto-Prompter
|
||||
T091-T100: Auto-Prompter, Critique Loop, Auto-Fix
|
||||
"""
|
||||
import logging
|
||||
import random
|
||||
from typing import Dict, Any, List, Optional
|
||||
|
||||
logger = logging.getLogger("SelfAI")
|
||||
|
||||
|
||||
class AutoPrompter:
|
||||
"""T091-T094: Genera prompts desde descripciones de vibe"""
|
||||
|
||||
VIBE_PATTERNS = {
|
||||
'techno': ['techno', 'industrial', 'warehouse', 'berlin', 'dark', 'hard', 'driving'],
|
||||
'house': ['house', 'deep', 'soulful', 'warm', 'groovy', 'jazzy', 'smooth'],
|
||||
'trance': ['trance', 'euphoric', 'uplifting', 'emotional', 'epic', 'melodic'],
|
||||
}
|
||||
|
||||
BPM_RANGES = {
|
||||
'slow': (85, 110),
|
||||
'medium': (115, 130),
|
||||
'fast': (130, 150),
|
||||
'very_fast': (150, 180),
|
||||
}
|
||||
|
||||
KEY_MOODS = {
|
||||
'dark': ['F#m', 'Gm', 'Am', 'Cm'],
|
||||
'bright': ['C', 'G', 'D', 'F'],
|
||||
'emotional': ['Em', 'Dm', 'Bm'],
|
||||
'mysterious': ['C#m', 'Ebm', 'G#m'],
|
||||
}
|
||||
|
||||
def __init__(self):
|
||||
self.logger = logging.getLogger("AutoPrompter")
|
||||
|
||||
def generate_from_vibe(self, vibe_text: str) -> Dict[str, Any]:
|
||||
"""
|
||||
T091-T093: Parsea descripción de vibe y genera parámetros.
|
||||
|
||||
Ejemplos:
|
||||
- "dark warehouse techno" → genre=techno, bpm=140, key=F#m
|
||||
- "deep house sunset" → genre=house, bpm=122, key=Gm
|
||||
- "euphoric trance" → genre=trance, bpm=138, key=C
|
||||
"""
|
||||
vibe_lower = vibe_text.lower()
|
||||
words = vibe_lower.split()
|
||||
|
||||
# Detectar género
|
||||
genre = self._detect_genre(words)
|
||||
|
||||
# Detectar BPM desde keywords de velocidad
|
||||
bpm = self._detect_bpm(words, genre)
|
||||
|
||||
# Detectar key desde mood
|
||||
key = self._detect_key(words)
|
||||
|
||||
# Detectar estilo
|
||||
style = self._detect_style(words, genre)
|
||||
|
||||
# Estructura recomendada
|
||||
structure = self._detect_structure(words)
|
||||
|
||||
return {
|
||||
'genre': genre,
|
||||
'bpm': bpm,
|
||||
'key': key,
|
||||
'style': style,
|
||||
'structure': structure,
|
||||
'prompt': f"{genre} {style}".strip(),
|
||||
'original_vibe': vibe_text,
|
||||
'confidence': self._calculate_confidence(words)
|
||||
}
|
||||
|
||||
def _detect_genre(self, words: List[str]) -> str:
|
||||
"""Detecta género desde palabras clave."""
|
||||
for genre, keywords in self.VIBE_PATTERNS.items():
|
||||
for word in words:
|
||||
if word in keywords:
|
||||
return genre
|
||||
return 'techno' # Default
|
||||
|
||||
def _detect_bpm(self, words: List[str], genre: str) -> int:
|
||||
"""Detecta BPM apropiado."""
|
||||
# Check for explicit BPM keywords
|
||||
speed_keywords = {
|
||||
'slow': 'slow',
|
||||
'medium': 'medium',
|
||||
'fast': 'fast',
|
||||
'hard': 'fast',
|
||||
'driving': 'fast',
|
||||
'chill': 'slow',
|
||||
'relaxed': 'slow',
|
||||
'intense': 'very_fast',
|
||||
'breakbeat': 'medium',
|
||||
}
|
||||
|
||||
for word in words:
|
||||
if word in speed_keywords:
|
||||
bpm_range = self.BPM_RANGES[speed_keywords[word]]
|
||||
return random.randint(bpm_range[0], bpm_range[1])
|
||||
|
||||
# Default por género
|
||||
genre_defaults = {
|
||||
'techno': (125, 140),
|
||||
'house': (118, 128),
|
||||
'trance': (135, 150),
|
||||
}
|
||||
bpm_range = genre_defaults.get(genre, (120, 130))
|
||||
return random.randint(bpm_range[0], bpm_range[1])
|
||||
|
||||
def _detect_key(self, words: List[str]) -> str:
|
||||
"""Detecta key desde mood."""
|
||||
for mood, keys in self.KEY_MOODS.items():
|
||||
if any(mood_word in words for mood_word in [mood, mood.replace('_', ' ')]):
|
||||
return random.choice(keys)
|
||||
|
||||
# Check for dark/bright keywords
|
||||
dark_words = ['dark', 'deep', 'moody', 'sad', 'melancholic', 'serious']
|
||||
if any(w in words for w in dark_words):
|
||||
return random.choice(self.KEY_MOODS['dark'])
|
||||
|
||||
bright_words = ['bright', 'happy', 'uplifting', 'cheerful', 'light']
|
||||
if any(w in words for w in bright_words):
|
||||
return random.choice(self.KEY_MOODS['bright'])
|
||||
|
||||
return 'Am' # Default
|
||||
|
||||
def _detect_style(self, words: List[str], genre: str) -> str:
|
||||
"""Detecta sub-estilo."""
|
||||
genre_styles = {
|
||||
'techno': ['industrial', 'peak-time', 'dub', 'minimal', 'melodic'],
|
||||
'house': ['deep', 'tech-house', 'progressive', 'afro', 'classic'],
|
||||
'trance': ['progressive', 'psy', 'uplifting', 'melodic'],
|
||||
}
|
||||
|
||||
styles = genre_styles.get(genre, [])
|
||||
for word in words:
|
||||
if word in styles:
|
||||
return word
|
||||
|
||||
return random.choice(styles) if styles else ''
|
||||
|
||||
def _detect_structure(self, words: List[str]) -> str:
|
||||
"""Detecta estructura recomendada."""
|
||||
if 'extended' in words or 'epic' in words or 'long' in words:
|
||||
return 'extended'
|
||||
if 'short' in words or 'quick' in words or 'minimal' in words:
|
||||
return 'minimal'
|
||||
return 'standard'
|
||||
|
||||
def _calculate_confidence(self, words: List[str]) -> float:
|
||||
"""Calcula confianza de la detección."""
|
||||
all_keywords = set()
|
||||
for keywords in self.VIBE_PATTERNS.values():
|
||||
all_keywords.update(keywords)
|
||||
|
||||
matches = sum(1 for word in words if word in all_keywords)
|
||||
return min(1.0, matches / 3.0) # Max confidence with 3+ matches
|
||||
|
||||
|
||||
class CritiqueEngine:
|
||||
"""T095-T097: Auto-evaluación post-generación"""
|
||||
|
||||
def __init__(self):
|
||||
self.logger = logging.getLogger("CritiqueEngine")
|
||||
|
||||
def critique_song(self, song_data: Dict) -> Dict:
|
||||
"""
|
||||
T095-T096: Evalúa la canción generada.
|
||||
Retorna score 1-10 por sección y lista de weaknesses.
|
||||
"""
|
||||
sections = song_data.get('sections', [])
|
||||
tracks = song_data.get('tracks', [])
|
||||
self._current_song_data = song_data or {}
|
||||
|
||||
scores = {
|
||||
'drums': self._score_drums(tracks),
|
||||
'bass': self._score_bass(tracks),
|
||||
'harmony': self._score_harmony(tracks),
|
||||
'arrangement': self._score_arrangement(sections),
|
||||
'mix': self._score_mix(tracks),
|
||||
}
|
||||
|
||||
overall = sum(scores.values()) / len(scores)
|
||||
|
||||
weaknesses = []
|
||||
if scores['drums'] < 5:
|
||||
weaknesses.append('drums: pattern too repetitive or weak')
|
||||
if scores['bass'] < 5:
|
||||
weaknesses.append('bass: lacks presence or key mismatch')
|
||||
if scores['harmony'] < 5:
|
||||
weaknesses.append('harmony: dissonant or static')
|
||||
if scores['arrangement'] < 5:
|
||||
weaknesses.append('arrangement: poor energy flow')
|
||||
if scores['mix'] < 5:
|
||||
weaknesses.append('mix: clipping or balance issues')
|
||||
|
||||
strengths = []
|
||||
if scores['drums'] >= 8:
|
||||
strengths.append('strong rhythmic foundation')
|
||||
if scores['bass'] >= 8:
|
||||
strengths.append('solid low-end')
|
||||
if scores['harmony'] >= 8:
|
||||
strengths.append('engaging harmonic content')
|
||||
|
||||
return {
|
||||
'overall_score': round(overall, 1),
|
||||
'section_scores': scores,
|
||||
'weaknesses': weaknesses,
|
||||
'strengths': strengths,
|
||||
'recommendations': self._generate_recommendations(weaknesses)
|
||||
}
|
||||
|
||||
def _score_drums(self, tracks: List[Dict]) -> int:
|
||||
"""Score 1-10 para drums."""
|
||||
roles = {
|
||||
str(t.get('role', '') or t.get('name', '')).lower()
|
||||
for t in tracks
|
||||
if any(token in str(t.get('role', '') or t.get('name', '')).lower()
|
||||
for token in ['kick', 'snare', 'clap', 'hat', 'perc', 'top'])
|
||||
}
|
||||
if not roles:
|
||||
return 3
|
||||
score = 4 + min(4, len(roles))
|
||||
if any('kick' in role for role in roles) and any(('snare' in role or 'clap' in role) for role in roles):
|
||||
score += 1
|
||||
if any('hat' in role for role in roles):
|
||||
score += 1
|
||||
return min(10, score)
|
||||
|
||||
def _score_bass(self, tracks: List[Dict]) -> int:
|
||||
"""Score 1-10 para bass."""
|
||||
bass_tracks = [
|
||||
t for t in tracks
|
||||
if any(token in str(t.get('role', '') or t.get('name', '')).lower() for token in ['bass', 'sub', '808'])
|
||||
]
|
||||
if not bass_tracks:
|
||||
return 3
|
||||
score = 5 + min(3, len(bass_tracks))
|
||||
if str((self._current_song_data or {}).get('key', '') or ''):
|
||||
score += 1
|
||||
return min(10, score)
|
||||
|
||||
def _score_harmony(self, tracks: List[Dict]) -> int:
|
||||
"""Score 1-10 para harmony."""
|
||||
harmony_tracks = [t for t in tracks if any(x in str(t.get('role', '') or t.get('name', '')).lower()
|
||||
for x in ['chord', 'synth', 'pad', 'lead', 'pluck', 'arp', 'vocal'])]
|
||||
if not harmony_tracks:
|
||||
return 4
|
||||
score = 4 + min(4, len(harmony_tracks))
|
||||
if str((self._current_song_data or {}).get('reference_name', '') or ''):
|
||||
score += 1
|
||||
return min(10, score)
|
||||
|
||||
def _score_arrangement(self, sections: List[Dict]) -> int:
|
||||
"""Score 1-10 para arrangement."""
|
||||
if len(sections) < 4:
|
||||
return 4
|
||||
kinds = {str(section.get('kind', '')).lower() for section in sections}
|
||||
score = 4 + min(4, len(kinds))
|
||||
score += min(2, len(kinds & {'intro', 'build', 'drop', 'break', 'outro'}))
|
||||
return min(10, score)
|
||||
|
||||
def _score_mix(self, tracks: List[Dict]) -> int:
|
||||
"""Score 1-10 para mix."""
|
||||
song_data = self._current_song_data or {}
|
||||
buses = song_data.get('buses', []) or []
|
||||
returns = song_data.get('returns', []) or []
|
||||
audio_layers = song_data.get('audio_layers', []) or []
|
||||
score = 4
|
||||
if buses:
|
||||
score += 2
|
||||
if returns:
|
||||
score += 1
|
||||
if audio_layers:
|
||||
score += 1
|
||||
if len(tracks) >= 8:
|
||||
score += 1
|
||||
return min(10, score)
|
||||
|
||||
def _generate_recommendations(self, weaknesses: List[str]) -> List[str]:
|
||||
"""Genera recomendaciones basadas en weaknesses."""
|
||||
recommendations = []
|
||||
for weakness in weaknesses:
|
||||
if 'drums' in weakness:
|
||||
recommendations.append('Add more drum variation or layer percussion')
|
||||
if 'bass' in weakness:
|
||||
recommendations.append('Check bass level and key alignment')
|
||||
if 'harmony' in weakness:
|
||||
recommendations.append('Add chord progression variation')
|
||||
if 'arrangement' in weakness:
|
||||
recommendations.append('Adjust energy curve between sections')
|
||||
if 'mix' in weakness:
|
||||
recommendations.append('Reduce levels to prevent clipping')
|
||||
return recommendations
|
||||
|
||||
|
||||
class AutoFixEngine:
|
||||
"""T098-T100: Auto-fix de problemas detectados"""
|
||||
|
||||
def __init__(self):
|
||||
self.logger = logging.getLogger("AutoFixEngine")
|
||||
|
||||
def auto_fix(self, critique_result: Dict, song_data: Dict) -> Dict:
|
||||
"""
|
||||
T098-T100: Aplica fixes automáticos basados en critique.
|
||||
|
||||
Retorna reporte de cambios aplicados.
|
||||
"""
|
||||
fixes_applied = []
|
||||
before_score = critique_result['overall_score']
|
||||
|
||||
weaknesses = critique_result.get('weaknesses', [])
|
||||
|
||||
for weakness in weaknesses:
|
||||
if 'drums' in weakness:
|
||||
self._fix_drums(song_data)
|
||||
fixes_applied.append('Regenerated drum patterns with more variation')
|
||||
|
||||
if 'bass' in weakness:
|
||||
self._fix_bass(song_data)
|
||||
fixes_applied.append('Adjusted bass level and key')
|
||||
|
||||
if 'harmony' in weakness:
|
||||
self._fix_harmony(song_data)
|
||||
fixes_applied.append('Added chord progression variation')
|
||||
|
||||
if 'mix' in weakness:
|
||||
self._fix_mix(song_data)
|
||||
fixes_applied.append('Reduced master levels')
|
||||
|
||||
# Recalcular score después de fixes (simulación)
|
||||
improvement = len(fixes_applied) * 0.5
|
||||
after_score = min(10.0, before_score + improvement)
|
||||
|
||||
return {
|
||||
'fixes_applied': fixes_applied,
|
||||
'before_score': before_score,
|
||||
'after_score': round(after_score, 1),
|
||||
'improvement': round(after_score - before_score, 1),
|
||||
}
|
||||
|
||||
def _fix_drums(self, song_data: Dict):
|
||||
"""Fix para drums débiles."""
|
||||
# Simulación - regeneraría patterns
|
||||
pass
|
||||
|
||||
def _fix_bass(self, song_data: Dict):
|
||||
"""Fix para bass."""
|
||||
# Simulación - ajustaría niveles y key
|
||||
pass
|
||||
|
||||
def _fix_harmony(self, song_data: Dict):
|
||||
"""Fix para harmony estática."""
|
||||
# Simulación - agregaría variación
|
||||
pass
|
||||
|
||||
def _fix_mix(self, song_data: Dict):
|
||||
"""Fix para mix issues."""
|
||||
# Simulación - reduciría niveles
|
||||
pass
|
||||
11079
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/server.py
Normal file
11079
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/server.py
Normal file
File diff suppressed because it is too large
Load Diff
798
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/socket_smoke_test.py
Normal file
798
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/socket_smoke_test.py
Normal file
@@ -0,0 +1,798 @@
|
||||
import argparse
|
||||
import json
|
||||
import socket
|
||||
from datetime import datetime
|
||||
from typing import Any, Dict, List, Tuple
|
||||
|
||||
try:
|
||||
from song_generator import SongGenerator
|
||||
except ImportError:
|
||||
SongGenerator = None
|
||||
|
||||
|
||||
STRUCTURE_SCENE_COUNTS = {
|
||||
"minimal": 4,
|
||||
"standard": 6,
|
||||
"extended": 7,
|
||||
}
|
||||
|
||||
# Expected buses for Phase 7 validation
|
||||
EXPECTED_BUSES = ["drums", "bass", "music", "vocal", "fx"]
|
||||
|
||||
EXPECTED_CRITICAL_ROLES = {"kick", "bass", "clap", "hat"}
|
||||
|
||||
EXPECTED_AUDIO_FX_LAYERS = ["AUDIO ATMOS", "AUDIO CRASH FX", "AUDIO TRANSITION FILL"]
|
||||
|
||||
EXPECTED_BUS_NAMES = ["DRUMS", "BASS", "MUSIC"]
|
||||
|
||||
MIN_TRACKS_FOR_EXPORT = 6
|
||||
MIN_BUSES_FOR_EXPORT = 3
|
||||
MIN_RETURNS_FOR_EXPORT = 2
|
||||
MASTER_VOLUME_RANGE = (0.75, 0.95)
|
||||
|
||||
# Expected AUDIO RESAMPLE track names
|
||||
AUDIO_RESAMPLE_TRACKS = [
|
||||
"AUDIO RESAMPLE REVERSE FX",
|
||||
"AUDIO RESAMPLE RISER",
|
||||
"AUDIO RESAMPLE DOWNLIFTER",
|
||||
"AUDIO RESAMPLE STUTTER",
|
||||
]
|
||||
|
||||
# Bus routing map: track role -> expected bus output
|
||||
BUS_ROUTING_MAP = {
|
||||
"kick": {"drums"},
|
||||
"snare": {"drums"},
|
||||
"clap": {"drums"},
|
||||
"hat": {"drums"},
|
||||
"perc": {"drums"},
|
||||
"sub_bass": {"bass"},
|
||||
"bass": {"bass"},
|
||||
"chords": {"music"},
|
||||
"pad": {"music"},
|
||||
"pluck": {"music"},
|
||||
"lead": {"music"},
|
||||
"vocal": {"vocal"},
|
||||
"vocal_chop": {"vocal"},
|
||||
"reverse_fx": {"fx"},
|
||||
"riser": {"fx"},
|
||||
"impact": {"fx"},
|
||||
"atmos": {"fx"},
|
||||
"crash": {"drums", "fx"},
|
||||
}
|
||||
|
||||
|
||||
def _extract_bus_payload(payload: Any) -> List[Dict[str, Any]]:
|
||||
if isinstance(payload, list):
|
||||
return [item for item in payload if isinstance(item, dict)]
|
||||
if isinstance(payload, dict):
|
||||
buses = payload.get("buses", [])
|
||||
if isinstance(buses, list):
|
||||
return [item for item in buses if isinstance(item, dict)]
|
||||
return []
|
||||
|
||||
|
||||
def _normalize_bus_key(name: str) -> str:
|
||||
normalized = "".join(ch for ch in (name or "").lower() if ch.isalnum())
|
||||
if not normalized:
|
||||
return ""
|
||||
if "drum" in normalized or "groove" in normalized:
|
||||
return "drums"
|
||||
if "bass" in normalized or "tube" in normalized or "subdeep" in normalized:
|
||||
return "bass"
|
||||
if "music" in normalized or "wide" in normalized:
|
||||
return "music"
|
||||
if "vocal" in normalized or "vox" in normalized or "tail" in normalized:
|
||||
return "vocal"
|
||||
if "fx" in normalized or "wash" in normalized:
|
||||
return "fx"
|
||||
return ""
|
||||
|
||||
|
||||
def _canonical_track_name(name: str) -> str:
|
||||
text = (name or "").strip().lower()
|
||||
if not text:
|
||||
return ""
|
||||
if " (" in text:
|
||||
text = text.split(" (", 1)[0].strip()
|
||||
return text
|
||||
|
||||
|
||||
class AbletonSocketClient:
|
||||
def __init__(self, host: str = "127.0.0.1", port: int = 9877, timeout: float = 15.0):
|
||||
self.host = host
|
||||
self.port = port
|
||||
self.timeout = timeout
|
||||
|
||||
def send(self, command_type: str, params: Dict[str, Any] = None) -> Dict[str, Any]:
|
||||
payload = json.dumps({
|
||||
"type": command_type,
|
||||
"params": params or {},
|
||||
}).encode("utf-8") + b"\n"
|
||||
|
||||
with socket.create_connection((self.host, self.port), timeout=self.timeout) as sock:
|
||||
sock.sendall(payload)
|
||||
reader = sock.makefile("r", encoding="utf-8")
|
||||
try:
|
||||
line = reader.readline()
|
||||
finally:
|
||||
reader.close()
|
||||
try:
|
||||
sock.shutdown(socket.SHUT_RDWR)
|
||||
except OSError:
|
||||
pass
|
||||
|
||||
if not line:
|
||||
raise RuntimeError(f"No response for command: {command_type}")
|
||||
|
||||
return json.loads(line)
|
||||
|
||||
|
||||
def expect_success(name: str, response: Dict[str, Any]) -> Dict[str, Any]:
|
||||
if response.get("status") != "success":
|
||||
raise RuntimeError(f"{name} failed: {response}")
|
||||
return response.get("result", {})
|
||||
|
||||
|
||||
class TestResult:
|
||||
"""Tracks test results for reporting."""
|
||||
def __init__(self):
|
||||
self.passed: List[Tuple[str, str]] = []
|
||||
self.failed: List[Tuple[str, str]] = []
|
||||
self.skipped: List[Tuple[str, str]] = []
|
||||
self.warnings: List[Tuple[str, str]] = []
|
||||
|
||||
def add_pass(self, name: str, details: str = ""):
|
||||
self.passed.append((name, details))
|
||||
|
||||
def add_fail(self, name: str, error: str):
|
||||
self.failed.append((name, error))
|
||||
|
||||
def add_skip(self, name: str, reason: str):
|
||||
self.skipped.append((name, reason))
|
||||
|
||||
def add_warning(self, name: str, message: str):
|
||||
self.warnings.append((name, message))
|
||||
|
||||
def to_dict(self) -> Dict[str, Any]:
|
||||
return {
|
||||
"summary": {
|
||||
"total": len(self.passed) + len(self.failed) + len(self.skipped) + len(self.warnings),
|
||||
"passed": len(self.passed),
|
||||
"failed": len(self.failed),
|
||||
"skipped": len(self.skipped),
|
||||
"warnings": len(self.warnings),
|
||||
"status": "PASS" if len(self.failed) == 0 else "FAIL",
|
||||
},
|
||||
"passed_tests": [{"name": n, "details": d} for n, d in self.passed],
|
||||
"failed_tests": [{"name": n, "error": d} for n, d in self.failed],
|
||||
"skipped_tests": [{"name": n, "reason": d} for n, d in self.skipped],
|
||||
"warnings": [{"name": n, "message": d} for n, d in self.warnings],
|
||||
}
|
||||
|
||||
def print_report(self):
|
||||
print("\n" + "=" * 60)
|
||||
print("PHASE 7 SMOKE TEST REPORT")
|
||||
print("=" * 60)
|
||||
print(f"Timestamp: {datetime.now().isoformat()}")
|
||||
print(f"Total: {len(self.passed) + len(self.failed) + len(self.skipped) + len(self.warnings)}")
|
||||
print(f"Passed: {len(self.passed)}")
|
||||
print(f"Failed: {len(self.failed)}")
|
||||
print(f"Skipped: {len(self.skipped)}")
|
||||
print(f"Warnings: {len(self.warnings)}")
|
||||
print("-" * 60)
|
||||
|
||||
if self.passed:
|
||||
print("\n[PASSED]")
|
||||
for name, details in self.passed:
|
||||
print(f" [OK] {name}: {details}")
|
||||
|
||||
if self.failed:
|
||||
print("\n[FAILED]")
|
||||
for name, error in self.failed:
|
||||
print(f" [FAIL] {name}: {error}")
|
||||
|
||||
if self.warnings:
|
||||
print("\n[WARNINGS]")
|
||||
for name, message in self.warnings:
|
||||
print(f" [WARN] {name}: {message}")
|
||||
|
||||
if self.skipped:
|
||||
print("\n[SKIPPED]")
|
||||
for name, reason in self.skipped:
|
||||
print(f" [SKIP] {name}: {reason}")
|
||||
|
||||
print("\n" + "=" * 60)
|
||||
status = "PASS" if len(self.failed) == 0 else "FAIL"
|
||||
print(f"FINAL STATUS: {status}")
|
||||
print("=" * 60 + "\n")
|
||||
|
||||
|
||||
def run_readonly_checks(client: AbletonSocketClient) -> List[Tuple[str, str]]:
|
||||
checks = []
|
||||
|
||||
expect_success("get_session_info", client.send("get_session_info"))
|
||||
checks.append((
|
||||
"get_session_info",
|
||||
# f"tempo={session.get('tempo')} tracks={session.get('num_tracks')} scenes={session.get('num_scenes')}",
|
||||
))
|
||||
|
||||
tracks = expect_success("get_tracks", client.send("get_tracks"))
|
||||
checks.append(("get_tracks", f"tracks={len(tracks)}"))
|
||||
|
||||
return checks
|
||||
|
||||
|
||||
def run_generation_check(
|
||||
client: AbletonSocketClient,
|
||||
genre: str,
|
||||
style: str,
|
||||
bpm: float,
|
||||
key: str,
|
||||
structure: str,
|
||||
use_blueprint: bool = False,
|
||||
) -> List[Tuple[str, str]]:
|
||||
checks = []
|
||||
params = {
|
||||
"genre": genre,
|
||||
"style": style,
|
||||
"bpm": bpm,
|
||||
"key": key,
|
||||
"structure": structure,
|
||||
}
|
||||
|
||||
if use_blueprint and SongGenerator is not None:
|
||||
params = SongGenerator().generate_config(genre, style, bpm, key, structure)
|
||||
|
||||
result = expect_success(
|
||||
"generate_complete_song",
|
||||
client.send("generate_complete_song", params),
|
||||
)
|
||||
checks.append((
|
||||
"generate_complete_song",
|
||||
f"tracks={result.get('tracks')} scenes={result.get('scenes')} structure={result.get('structure')}",
|
||||
))
|
||||
|
||||
session = expect_success("post_generate_session_info", client.send("get_session_info"))
|
||||
actual_scenes = session.get("num_scenes")
|
||||
expected_scenes = len(params.get("sections", [])) if use_blueprint and isinstance(params, dict) and params.get("sections") else STRUCTURE_SCENE_COUNTS.get(structure.lower())
|
||||
if expected_scenes is not None and actual_scenes != expected_scenes:
|
||||
raise RuntimeError(
|
||||
f"scene count mismatch after generate_complete_song: expected {expected_scenes}, got {actual_scenes}"
|
||||
)
|
||||
|
||||
checks.append((
|
||||
"post_generate_session_info",
|
||||
f"tracks={session.get('num_tracks')} scenes={actual_scenes}",
|
||||
))
|
||||
|
||||
return checks
|
||||
|
||||
|
||||
def run_bus_checks(client: AbletonSocketClient, results: TestResult) -> None:
|
||||
"""Verify buses are created correctly."""
|
||||
try:
|
||||
buses_payload = expect_success("list_buses", client.send("list_buses"))
|
||||
buses = _extract_bus_payload(buses_payload)
|
||||
bus_keys = {_normalize_bus_key(bus.get("name", "")) for bus in buses}
|
||||
bus_keys.discard("")
|
||||
|
||||
found_buses = []
|
||||
missing_buses = []
|
||||
for expected in EXPECTED_BUSES:
|
||||
if expected in bus_keys:
|
||||
found_buses.append(expected)
|
||||
else:
|
||||
missing_buses.append(expected)
|
||||
|
||||
if found_buses:
|
||||
results.add_pass("buses_found", f"found={found_buses}")
|
||||
|
||||
if missing_buses:
|
||||
# Not a failure if buses don't exist yet - they may be created during generation
|
||||
results.add_skip("buses_missing", f"not_found={missing_buses} (may be created during generation)")
|
||||
else:
|
||||
results.add_pass("buses_complete", "all expected buses present")
|
||||
|
||||
except Exception as e:
|
||||
results.add_fail("buses_check", str(e))
|
||||
|
||||
|
||||
def run_routing_checks(client: AbletonSocketClient, results: TestResult) -> None:
|
||||
"""Verify track routing is configured correctly."""
|
||||
try:
|
||||
tracks = expect_success("get_tracks", client.send("get_tracks"))
|
||||
|
||||
if not tracks:
|
||||
results.add_skip("routing_check", "no tracks to verify routing")
|
||||
return
|
||||
|
||||
correct_routing = 0
|
||||
incorrect_routing = []
|
||||
no_routing = 0
|
||||
|
||||
for track in tracks:
|
||||
original_track_name = track.get("name", "")
|
||||
track_name = _canonical_track_name(original_track_name)
|
||||
output_routing = track.get("current_output_routing", "")
|
||||
output_bus_key = _normalize_bus_key(output_routing)
|
||||
track_bus_key = _normalize_bus_key(track_name)
|
||||
|
||||
if output_routing and output_routing.lower() != "master":
|
||||
correct_routing += 1
|
||||
elif not output_routing:
|
||||
no_routing += 1
|
||||
|
||||
if track_bus_key:
|
||||
continue
|
||||
|
||||
for role, expected_bus in BUS_ROUTING_MAP.items():
|
||||
if role in track_name:
|
||||
if output_bus_key in expected_bus:
|
||||
correct_routing += 1
|
||||
elif output_routing.lower() != "master":
|
||||
expected_label = "/".join(sorted(expected_bus))
|
||||
incorrect_routing.append(f"{original_track_name.lower()} -> {output_routing} (expected {expected_label})")
|
||||
|
||||
results.add_pass("routing_summary", f"correct={correct_routing} no_routing={no_routing}")
|
||||
|
||||
if incorrect_routing:
|
||||
results.add_fail("routing_mismatches", ", ".join(incorrect_routing[:5]))
|
||||
elif correct_routing > 0:
|
||||
results.add_pass("routing_correct", f"{correct_routing} tracks with non-master routing")
|
||||
|
||||
except Exception as e:
|
||||
results.add_fail("routing_check", str(e))
|
||||
|
||||
|
||||
def run_audio_resample_checks(client: AbletonSocketClient, results: TestResult) -> None:
|
||||
"""Verify AUDIO RESAMPLE tracks exist."""
|
||||
try:
|
||||
tracks = expect_success("get_tracks", client.send("get_tracks"))
|
||||
track_names = [t.get("name", "") for t in tracks]
|
||||
|
||||
found_layers = []
|
||||
missing_layers = []
|
||||
|
||||
for expected in AUDIO_RESAMPLE_TRACKS:
|
||||
if any(expected.upper() in name.upper() for name in track_names):
|
||||
found_layers.append(expected)
|
||||
else:
|
||||
missing_layers.append(expected)
|
||||
|
||||
if found_layers:
|
||||
results.add_pass("audio_resample_found", f"layers={found_layers}")
|
||||
|
||||
if missing_layers:
|
||||
results.add_skip("audio_resample_missing", f"not_found={missing_layers} (may require reference audio)")
|
||||
else:
|
||||
results.add_pass("audio_resample_complete", "all 4 resample layers present")
|
||||
|
||||
# Verify they are audio tracks
|
||||
for track in tracks:
|
||||
name = track.get("name", "").upper()
|
||||
if "AUDIO RESAMPLE" in name:
|
||||
if track.get("has_audio_input"):
|
||||
results.add_pass(f"audio_track_type_{name[:20]}", "correct audio track type")
|
||||
else:
|
||||
results.add_fail(f"audio_track_type_{name[:20]}", "expected audio track")
|
||||
|
||||
except Exception as e:
|
||||
results.add_fail("audio_resample_check", str(e))
|
||||
|
||||
|
||||
def run_automation_snapshot_checks(client: AbletonSocketClient, results: TestResult) -> None:
|
||||
"""Verify automation and device parameter snapshots."""
|
||||
try:
|
||||
tracks = expect_success("get_tracks", client.send("get_tracks"))
|
||||
|
||||
total_devices = 0
|
||||
tracks_with_devices = 0
|
||||
tracks_with_automation = 0
|
||||
|
||||
for track in tracks:
|
||||
num_devices = track.get("num_devices", 0)
|
||||
if num_devices > 0:
|
||||
total_devices += num_devices
|
||||
tracks_with_devices += 1
|
||||
|
||||
# Check for arrangement clips (may contain automation)
|
||||
arrangement_clips = track.get("arrangement_clip_count", 0)
|
||||
if arrangement_clips > 0:
|
||||
tracks_with_automation += 1
|
||||
|
||||
if tracks_with_devices > 0:
|
||||
results.add_pass("automation_devices", f"tracks_with_devices={tracks_with_devices} total_devices={total_devices}")
|
||||
else:
|
||||
results.add_skip("automation_devices", "no devices found")
|
||||
|
||||
if tracks_with_automation > 0:
|
||||
results.add_pass("automation_clips", f"tracks_with_arrangement_clips={tracks_with_automation}")
|
||||
else:
|
||||
results.add_skip("automation_clips", "no arrangement clips (may need to commit to arrangement)")
|
||||
|
||||
# Try to get device parameters for first track with devices
|
||||
for i, track in enumerate(tracks):
|
||||
if track.get("num_devices", 0) > 0:
|
||||
try:
|
||||
devices = expect_success("get_devices", client.send("get_devices", {"track_index": i}))
|
||||
if devices:
|
||||
params_sample = []
|
||||
for dev in devices[:3]:
|
||||
params = dev.get("parameters", [])
|
||||
if params:
|
||||
params_sample.append(f"{dev.get('name', '?')}:{len(params)}params")
|
||||
if params_sample:
|
||||
results.add_pass("automation_params_snapshot", ", ".join(params_sample[:3]))
|
||||
break
|
||||
except Exception:
|
||||
pass
|
||||
break
|
||||
|
||||
except Exception as e:
|
||||
results.add_fail("automation_snapshot_check", str(e))
|
||||
|
||||
|
||||
def run_loudness_checks(client: AbletonSocketClient, results: TestResult) -> None:
|
||||
"""Verify basic loudness levels using output meters."""
|
||||
try:
|
||||
tracks = expect_success("get_tracks", client.send("get_tracks"))
|
||||
|
||||
tracks_with_signal = 0
|
||||
max_level = 0.0
|
||||
level_samples = []
|
||||
|
||||
for track in tracks:
|
||||
output_level = track.get("output_meter_level", 0.0)
|
||||
left = track.get("output_meter_left", 0.0)
|
||||
right = track.get("output_meter_right", 0.0)
|
||||
|
||||
if output_level and output_level > 0:
|
||||
tracks_with_signal += 1
|
||||
max_level = max(max_level, output_level)
|
||||
level_samples.append(f"{track.get('name', '?')[:15]}:{output_level:.2f}")
|
||||
|
||||
# Check for stereo balance
|
||||
if left and right and left > 0 and right > 0:
|
||||
balance = abs(left - right)
|
||||
if balance < 0.1:
|
||||
pass # Balanced stereo
|
||||
|
||||
if tracks_with_signal > 0:
|
||||
results.add_pass("loudness_signal_detected", f"tracks_with_signal={tracks_with_signal} max_level={max_level:.3f}")
|
||||
else:
|
||||
results.add_skip("loudness_signal", "no signal detected (playback may be stopped)")
|
||||
|
||||
# Check for clipping (levels > 1.0)
|
||||
if max_level > 1.0:
|
||||
results.add_fail("loudness_clipping", f"max_level={max_level:.3f} indicates potential clipping")
|
||||
else:
|
||||
results.add_pass("loudness_no_clipping", f"max_level={max_level:.3f}")
|
||||
|
||||
# Sample levels for verification
|
||||
if level_samples:
|
||||
results.add_pass("loudness_levels", ", ".join(level_samples[:5]))
|
||||
|
||||
except Exception as e:
|
||||
results.add_fail("loudness_check", str(e))
|
||||
|
||||
|
||||
def run_critical_layer_checks(client: AbletonSocketClient, results: TestResult) -> None:
|
||||
"""Verify critical layers (kick, bass, clap, hat) exist and have content."""
|
||||
try:
|
||||
tracks = expect_success("get_tracks", client.send("get_tracks"))
|
||||
track_names = [str(t.get("name", "")).upper() for t in tracks if isinstance(t, dict)]
|
||||
|
||||
found_layers = {role: False for role in EXPECTED_CRITICAL_ROLES}
|
||||
for track_name in track_names:
|
||||
for role in EXPECTED_CRITICAL_ROLES:
|
||||
if role.upper() in track_name or f"AUDIO {role.upper()}" in track_name:
|
||||
found_layers[role] = True
|
||||
break
|
||||
|
||||
for role, found in found_layers.items():
|
||||
if found:
|
||||
results.add_pass(f"critical_layer_{role}", "found in tracks")
|
||||
else:
|
||||
results.add_fail(f"critical_layer_{role}", "missing - set may sound incomplete")
|
||||
except Exception as e:
|
||||
results.add_fail("critical_layer_check", str(e))
|
||||
|
||||
|
||||
def run_derived_fx_checks(client: AbletonSocketClient, results: TestResult) -> None:
|
||||
"""Verify derived FX tracks (AUDIO RESAMPLE) are present."""
|
||||
try:
|
||||
tracks = expect_success("get_tracks", client.send("get_tracks"))
|
||||
track_names = [str(t.get("name", "")).upper() for t in tracks if isinstance(t, dict)]
|
||||
|
||||
found_derived = []
|
||||
missing_derived = []
|
||||
for expected in AUDIO_RESAMPLE_TRACKS:
|
||||
if any(expected.upper() in name for name in track_names):
|
||||
found_derived.append(expected)
|
||||
else:
|
||||
missing_derived.append(expected)
|
||||
|
||||
if found_derived:
|
||||
results.add_pass("derived_fx_found", f"layers={found_derived}")
|
||||
|
||||
if missing_derived:
|
||||
results.add_skip("derived_fx_missing", f"not_found={missing_derived} (may require reference audio)")
|
||||
else:
|
||||
results.add_pass("derived_fx_complete", "all 4 resample layers present")
|
||||
|
||||
except Exception as e:
|
||||
results.add_fail("derived_fx_check", str(e))
|
||||
|
||||
|
||||
def run_export_readiness_checks(client: AbletonSocketClient, results: TestResult) -> None:
|
||||
"""Verify set is ready for export."""
|
||||
try:
|
||||
expect_success("get_session_info", client.send("get_session_info"))
|
||||
tracks = expect_success("get_tracks", client.send("get_tracks"))
|
||||
|
||||
issues = []
|
||||
|
||||
track_count = len(tracks) if isinstance(tracks, list) else 0
|
||||
if track_count < MIN_TRACKS_FOR_EXPORT:
|
||||
issues.append(f"insufficient_tracks: {track_count} (need {MIN_TRACKS_FOR_EXPORT}+)")
|
||||
|
||||
master_response = client.send("get_track_info", {"track_type": "master", "track_index": 0})
|
||||
if master_response.get("status") == "success":
|
||||
master_volume = float(master_response.get("result", {}).get("volume", 0.85))
|
||||
if master_volume < MASTER_VOLUME_RANGE[0]:
|
||||
issues.append(f"master_volume_low: {master_volume:.2f}")
|
||||
elif master_volume > MASTER_VOLUME_RANGE[1]:
|
||||
issues.append(f"master_volume_high: {master_volume:.2f}")
|
||||
|
||||
muted_count = sum(1 for t in tracks if isinstance(t, dict) and t.get("mute", False))
|
||||
if muted_count > track_count * 0.5:
|
||||
issues.append(f"too_many_muted: {muted_count}/{track_count}")
|
||||
|
||||
if issues:
|
||||
results.add_pass("export_readiness_issues", f"issues={len(issues)}")
|
||||
for issue in issues:
|
||||
results.add_fail(f"export_ready_{issue.split(':')[0]}", issue)
|
||||
else:
|
||||
results.add_pass("export_ready", "set appears ready for export")
|
||||
|
||||
except Exception as e:
|
||||
results.add_fail("export_readiness_check", str(e))
|
||||
|
||||
|
||||
def run_midi_clip_content_checks(client: AbletonSocketClient, results: TestResult) -> None:
|
||||
"""Verify MIDI tracks have clips with notes."""
|
||||
try:
|
||||
tracks = expect_success("get_tracks", client.send("get_tracks"))
|
||||
|
||||
midi_tracks_empty = []
|
||||
midi_tracks_with_notes = 0
|
||||
|
||||
for track in tracks:
|
||||
if not isinstance(track, dict):
|
||||
continue
|
||||
track_type = str(track.get("type", "")).lower()
|
||||
if track_type != "midi":
|
||||
continue
|
||||
|
||||
track_name = track.get("name", "?")
|
||||
clips = track.get("clips", [])
|
||||
if not isinstance(clips, list):
|
||||
clips = []
|
||||
|
||||
has_notes = False
|
||||
empty_clips = []
|
||||
for clip in clips:
|
||||
if not isinstance(clip, dict):
|
||||
continue
|
||||
notes_count = clip.get("notes_count", 0)
|
||||
has_notes_flag = clip.get("has_notes", None)
|
||||
if has_notes_flag is True or notes_count > 0:
|
||||
has_notes = True
|
||||
elif has_notes_flag is False or (has_notes_flag is None and notes_count == 0):
|
||||
empty_clips.append(clip.get("name", "?"))
|
||||
if has_notes:
|
||||
midi_tracks_with_notes += 1
|
||||
elif empty_clips:
|
||||
midi_tracks_empty.append({
|
||||
"track_name": track_name,
|
||||
"empty_clips_count": len(empty_clips),
|
||||
})
|
||||
|
||||
if midi_tracks_with_notes > 0:
|
||||
results.add_pass("midi_tracks_with_notes", f"count={midi_tracks_with_notes}")
|
||||
|
||||
if midi_tracks_empty:
|
||||
for track_info in midi_tracks_empty[:3]:
|
||||
results.add_fail(
|
||||
f"midi_track_empty_{track_info['track_name'][:20]}",
|
||||
f"Track has {track_info['empty_clips_count']} empty MIDI clips - may need notes"
|
||||
)
|
||||
|
||||
except Exception as e:
|
||||
results.add_fail("midi_clip_content_check", str(e))
|
||||
|
||||
|
||||
def run_bus_signal_checks(client: AbletonSocketClient, results: TestResult) -> None:
|
||||
"""Verify buses receive signal from tracks."""
|
||||
try:
|
||||
buses_payload = expect_success("list_buses", client.send("list_buses"))
|
||||
buses = _extract_bus_payload(buses_payload)
|
||||
tracks = expect_success("get_tracks", client.send("get_tracks"))
|
||||
|
||||
bus_signal_map = {}
|
||||
for bus in buses:
|
||||
if not isinstance(bus, dict):
|
||||
continue
|
||||
bus_name = bus.get("name", "").upper()
|
||||
bus_signal_map[bus_name] = {"senders": [], "has_signal": False}
|
||||
|
||||
for track in tracks:
|
||||
if not isinstance(track, dict):
|
||||
continue
|
||||
track_name = str(track.get("name", "")).upper()
|
||||
output_routing = str(track.get("current_output_routing", "")).upper()
|
||||
|
||||
for bus_name in bus_signal_map:
|
||||
if bus_name in output_routing:
|
||||
bus_signal_map[bus_name]["senders"].append(track_name)
|
||||
|
||||
sends = track.get("sends", [])
|
||||
if isinstance(sends, list):
|
||||
for send_level in sends:
|
||||
try:
|
||||
if float(send_level) > 0.01:
|
||||
pass
|
||||
except (TypeError, ValueError):
|
||||
pass
|
||||
|
||||
buses_without_senders = []
|
||||
buses_with_senders = []
|
||||
|
||||
for bus_name, info in bus_signal_map.items():
|
||||
if info["senders"]:
|
||||
buses_with_senders.append(bus_name)
|
||||
else:
|
||||
buses_without_senders.append(bus_name)
|
||||
|
||||
if buses_with_senders:
|
||||
results.add_pass("buses_with_signal", f"buses={buses_with_senders}")
|
||||
|
||||
if buses_without_senders:
|
||||
for bus_name in buses_without_senders[:3]:
|
||||
results.add_fail(f"bus_no_signal_{bus_name[:15]}",
|
||||
f"Bus '{bus_name}' has no routed tracks - will not produce output")
|
||||
|
||||
except Exception as e:
|
||||
results.add_fail("bus_signal_check", str(e))
|
||||
|
||||
|
||||
def run_clipping_detection(client: AbletonSocketClient, results: TestResult) -> None:
|
||||
"""Detect tracks with dangerously high volume (clipping risk)."""
|
||||
try:
|
||||
tracks = expect_success("get_tracks", client.send("get_tracks"))
|
||||
|
||||
clipping_tracks = []
|
||||
high_volume_tracks = []
|
||||
|
||||
for track in tracks:
|
||||
if not isinstance(track, dict):
|
||||
continue
|
||||
track_name = track.get("name", "?")
|
||||
volume = float(track.get("volume", 0.85))
|
||||
|
||||
if volume > 0.95:
|
||||
clipping_tracks.append({"name": track_name, "volume": volume})
|
||||
elif volume > 0.90:
|
||||
high_volume_tracks.append({"name": track_name, "volume": volume})
|
||||
|
||||
if clipping_tracks:
|
||||
for track_info in clipping_tracks[:3]:
|
||||
results.add_fail(f"clipping_track_{track_info['name'][:15]}",f"Volume {track_info['volume']:.2f} > 0.95 - CLIPPING RISK")
|
||||
|
||||
if high_volume_tracks:
|
||||
for track_info in high_volume_tracks[:3]:
|
||||
results.add_warning(f"high_volume_{track_info['name'][:15]}",
|
||||
f"Volume {track_info['volume']:.2f} - consider reducing")
|
||||
|
||||
if not clipping_tracks and not high_volume_tracks:
|
||||
results.add_pass("no_clipping_tracks", "All track volumes in safe range")
|
||||
|
||||
except Exception as e:
|
||||
results.add_fail("clipping_detection", str(e))
|
||||
|
||||
|
||||
def run_all_phase7_tests(client: AbletonSocketClient, results: TestResult) -> None:
|
||||
"""Run all Phase 7 smoke tests."""
|
||||
print("\n[Phase 7] Running bus verification...")
|
||||
run_bus_checks(client, results)
|
||||
|
||||
print("[Phase 7] Running routing verification...")
|
||||
run_routing_checks(client, results)
|
||||
|
||||
print("[Phase 7] Running AUDIO RESAMPLE track verification...")
|
||||
run_audio_resample_checks(client, results)
|
||||
|
||||
print("[Phase 7] Running automation snapshot verification...")
|
||||
run_automation_snapshot_checks(client, results)
|
||||
|
||||
print("[Phase 7] Running loudness verification...")
|
||||
run_loudness_checks(client, results)
|
||||
|
||||
print("[Phase 7] Running critical layer verification...")
|
||||
run_critical_layer_checks(client, results)
|
||||
|
||||
print("[Phase 7] Running derived FX verification...")
|
||||
run_derived_fx_checks(client, results)
|
||||
|
||||
print("[Phase 7] Running export readiness verification...")
|
||||
run_export_readiness_checks(client, results)
|
||||
|
||||
print("[Phase 7] Running MIDI clip content verification...")
|
||||
run_midi_clip_content_checks(client, results)
|
||||
|
||||
print("[Phase 7] Running bus signal verification...")
|
||||
run_bus_signal_checks(client, results)
|
||||
|
||||
print("[Phase 7] Running clipping detection...")
|
||||
run_clipping_detection(client, results)
|
||||
|
||||
|
||||
def main() -> int:
|
||||
parser = argparse.ArgumentParser(description="Smoke test for AbletonMCP_AI socket runtime")
|
||||
parser.add_argument("--host", default="127.0.0.1")
|
||||
parser.add_argument("--port", type=int, default=9877)
|
||||
parser.add_argument("--timeout", type=float, default=15.0)
|
||||
parser.add_argument("--generate-demo", action="store_true")
|
||||
parser.add_argument("--genre", default="techno")
|
||||
parser.add_argument("--style", default="industrial")
|
||||
parser.add_argument("--bpm", type=float, default=128.0)
|
||||
parser.add_argument("--key", default="Am")
|
||||
parser.add_argument("--structure", default="standard")
|
||||
parser.add_argument("--use-blueprint", action="store_true")
|
||||
parser.add_argument("--phase7", action="store_true", help="Run Phase 7 extended tests (buses, routing, audio resample, automation, loudness)")
|
||||
parser.add_argument("--json-report", action="store_true", help="Output report as JSON")
|
||||
args = parser.parse_args()
|
||||
|
||||
client = AbletonSocketClient(host=args.host, port=args.port, timeout=args.timeout)
|
||||
|
||||
# Run basic checks
|
||||
print("[Basic] Running readonly checks...")
|
||||
checks = run_readonly_checks(client)
|
||||
|
||||
for name, details in checks:
|
||||
print(f"[ok] {name}: {details}")
|
||||
|
||||
# Run generation check if requested
|
||||
if args.generate_demo:
|
||||
print("\n[Generation] Running generation check...")
|
||||
checks.extend(
|
||||
run_generation_check(
|
||||
client,
|
||||
genre=args.genre,
|
||||
style=args.style,
|
||||
bpm=args.bpm,
|
||||
key=args.key,
|
||||
structure=args.structure,
|
||||
use_blueprint=args.use_blueprint,
|
||||
)
|
||||
)
|
||||
for name, details in checks[-2:]:
|
||||
print(f"[ok] {name}: {details}")
|
||||
|
||||
# Run Phase 7 tests if requested
|
||||
results = TestResult()
|
||||
if args.phase7:
|
||||
run_all_phase7_tests(client, results)
|
||||
|
||||
if args.json_report:
|
||||
print(json.dumps(results.to_dict(), indent=2))
|
||||
else:
|
||||
results.print_report()
|
||||
|
||||
return 0 if len(results.failed) == 0 else 1
|
||||
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
12486
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/song_generator.py
Normal file
12486
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/song_generator.py
Normal file
File diff suppressed because it is too large
Load Diff
16
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/start_server.py
Normal file
16
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/start_server.py
Normal file
@@ -0,0 +1,16 @@
|
||||
"""Wrapper to start MCP server with correct environment"""
|
||||
import sys
|
||||
import os
|
||||
|
||||
# Force correct working directory
|
||||
os.chdir(r'C:\ProgramData\Ableton\Live 12 Suite\Resources\MIDI Remote Scripts\AbletonMCP_AI\MCP_Server')
|
||||
|
||||
# Set up Python path for imports
|
||||
sys.path.insert(0, r'C:\ProgramData\Ableton\Live 12 Suite\Resources\MIDI Remote Scripts\AbletonMCP_AI\MCP_Server')
|
||||
sys.path.insert(0, r'C:\ProgramData\Ableton\Live 12 Suite\Resources\MIDI Remote Scripts\AbletonMCP_AI')
|
||||
|
||||
# Now import and run server
|
||||
import importlib.util
|
||||
spec = importlib.util.spec_from_file_location("server", "server.py")
|
||||
server = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(server)
|
||||
43
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/temp_tool.py
Normal file
43
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/temp_tool.py
Normal file
@@ -0,0 +1,43 @@
|
||||
|
||||
@mcp.tool()
|
||||
def generate_with_human_feel(ctx: Context, genre: str, bpm: float = 0, key: str = "",
|
||||
humanize: bool = True, groove_style: str = "shuffle",
|
||||
structure: str = "standard") -> str:
|
||||
"""
|
||||
T040-T050: Genera un track con human feel aplicado.
|
||||
|
||||
Args:
|
||||
genre: Genero musical
|
||||
bpm: BPM (0 = auto)
|
||||
key: Tonalidad
|
||||
humanize: Aplicar humanizacion de timing/velocity
|
||||
groove_style: Estilo de groove (straight, shuffle, triplet, latin)
|
||||
structure: Estructura de la cancion
|
||||
"""
|
||||
try:
|
||||
logger.info(f"Generando {genre} con human feel (groove={groove_style})")
|
||||
|
||||
# Get generator
|
||||
generator = get_song_generator()
|
||||
|
||||
# Select palette anchors first
|
||||
palette = _select_anchor_folders(genre, key, bpm)
|
||||
|
||||
# Generate config with palette
|
||||
config = generator.generate_config(genre, style="", bpm=bpm, key=key,
|
||||
structure=structure, palette=palette)
|
||||
|
||||
# Initialize human feel engine
|
||||
human_engine = HumanFeelEngine(seed=config.get('variant_seed', 42))
|
||||
|
||||
return json.dumps({
|
||||
"status": "success",
|
||||
"action": "generate_with_human_feel",
|
||||
"config": config,
|
||||
"palette": palette,
|
||||
"humanize": humanize,
|
||||
"groove_style": groove_style,
|
||||
"timestamp": time.strftime("%Y-%m-%d %H:%M:%S")
|
||||
}, indent=2)
|
||||
except Exception as e:
|
||||
return json.dumps({"error": str(e)}, indent=2)
|
||||
177
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/template_analyzer.py
Normal file
177
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/template_analyzer.py
Normal file
@@ -0,0 +1,177 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import gzip
|
||||
import json
|
||||
from collections import Counter
|
||||
from pathlib import Path
|
||||
import xml.etree.ElementTree as ET
|
||||
|
||||
|
||||
def _node_name(node: ET.Element | None) -> str:
|
||||
if node is None:
|
||||
return ""
|
||||
for tag in ("EffectiveName", "UserName", "Name"):
|
||||
child = node.find(tag)
|
||||
if child is not None:
|
||||
value = child.attrib.get("Value", "")
|
||||
if value:
|
||||
return value
|
||||
return node.attrib.get("Value", "")
|
||||
|
||||
|
||||
def _device_name(device: ET.Element) -> str:
|
||||
if device.tag == "PluginDevice":
|
||||
info = device.find("PluginDesc/VstPluginInfo")
|
||||
if info is None:
|
||||
info = device.find("PluginDesc/AuPluginInfo")
|
||||
if info is not None:
|
||||
plug = info.find("PlugName")
|
||||
if plug is not None and plug.attrib.get("Value"):
|
||||
return plug.attrib["Value"]
|
||||
return device.tag
|
||||
|
||||
|
||||
def _session_clip_count(track: ET.Element) -> int:
|
||||
count = 0
|
||||
for slot in track.findall("./DeviceChain/MainSequencer/ClipSlotList/ClipSlot"):
|
||||
if slot.find("Value/MidiClip") is not None or slot.find("Value/AudioClip") is not None:
|
||||
count += 1
|
||||
return count
|
||||
|
||||
|
||||
def _arrangement_clip_count(track: ET.Element) -> int:
|
||||
return len(track.findall(".//MainSequencer//MidiClip")) + len(
|
||||
track.findall(".//MainSequencer//AudioClip")
|
||||
)
|
||||
|
||||
|
||||
def _tempo_value(live_set: ET.Element) -> float | None:
|
||||
node = live_set.find(".//Tempo/Manual")
|
||||
if node is None:
|
||||
return None
|
||||
try:
|
||||
return float(node.attrib.get("Value", "0"))
|
||||
except ValueError:
|
||||
return None
|
||||
|
||||
|
||||
def _locator_summary(live_set: ET.Element) -> list[dict[str, float | str | None]]:
|
||||
locators: list[tuple[float, str]] = []
|
||||
for locator in live_set.findall(".//Locators/Locators/Locator"):
|
||||
try:
|
||||
time = float(locator.find("Time").attrib.get("Value", "0"))
|
||||
except (AttributeError, ValueError):
|
||||
time = 0.0
|
||||
name = _node_name(locator.find("Name"))
|
||||
locators.append((time, name))
|
||||
locators.sort(key=lambda item: item[0])
|
||||
summary: list[dict[str, float | str | None]] = []
|
||||
for index, (time, name) in enumerate(locators):
|
||||
next_time = locators[index + 1][0] if index + 1 < len(locators) else None
|
||||
summary.append(
|
||||
{
|
||||
"time_beats": time,
|
||||
"name": name,
|
||||
"section_length_beats": None if next_time is None else next_time - time,
|
||||
}
|
||||
)
|
||||
return summary
|
||||
|
||||
|
||||
def _arrangement_length_beats(root: ET.Element) -> float:
|
||||
max_end = 0.0
|
||||
for clip in root.findall(".//MidiClip") + root.findall(".//AudioClip"):
|
||||
current_end = clip.find("CurrentEnd")
|
||||
start = clip.attrib.get("Time")
|
||||
if current_end is None or start is None:
|
||||
continue
|
||||
try:
|
||||
end = float(start) + float(current_end.attrib.get("Value", "0"))
|
||||
except ValueError:
|
||||
continue
|
||||
max_end = max(max_end, end)
|
||||
return max_end
|
||||
|
||||
|
||||
def analyze_set(als_path: Path) -> dict:
|
||||
with gzip.open(als_path, "rb") as handle:
|
||||
root = ET.parse(handle).getroot()
|
||||
live_set = root.find("LiveSet")
|
||||
if live_set is None:
|
||||
raise ValueError(f"Invalid ALS file: {als_path}")
|
||||
|
||||
tracks = list(live_set.find("Tracks") or [])
|
||||
track_summaries = []
|
||||
device_counter: Counter[str] = Counter()
|
||||
|
||||
for track in tracks:
|
||||
devices = track.findall("./DeviceChain/DeviceChain/Devices/*")
|
||||
device_names = [_device_name(device) for device in devices]
|
||||
device_counter.update(device_names)
|
||||
track_summaries.append(
|
||||
{
|
||||
"type": track.tag,
|
||||
"name": _node_name(track.find("Name")),
|
||||
"group_id": track.find("TrackGroupId").attrib.get("Value", "")
|
||||
if track.find("TrackGroupId") is not None
|
||||
else "",
|
||||
"session_clip_count": _session_clip_count(track),
|
||||
"arrangement_clip_count": _arrangement_clip_count(track),
|
||||
"devices": device_names,
|
||||
}
|
||||
)
|
||||
|
||||
automation_events = 0
|
||||
for automation in root.findall(".//ArrangerAutomation"):
|
||||
automation_events += len(automation.findall(".//FloatEvent"))
|
||||
automation_events += len(automation.findall(".//EnumEvent"))
|
||||
automation_events += len(automation.findall(".//BoolEvent"))
|
||||
|
||||
return {
|
||||
"file": str(als_path),
|
||||
"tempo": _tempo_value(live_set),
|
||||
"track_type_counts": dict(Counter(track.tag for track in tracks)),
|
||||
"scene_count": len(live_set.findall("./SceneNames/Scene")),
|
||||
"locators": _locator_summary(live_set),
|
||||
"arrangement_length_beats": _arrangement_length_beats(root),
|
||||
"automation_event_count": automation_events,
|
||||
"top_devices": dict(device_counter.most_common(16)),
|
||||
"tracks": track_summaries,
|
||||
}
|
||||
|
||||
|
||||
def main() -> None:
|
||||
parser = argparse.ArgumentParser(description="Analyze Ableton .als templates.")
|
||||
parser.add_argument("path", nargs="?", default=".", help="Folder containing .als files")
|
||||
parser.add_argument("--json", action="store_true", help="Emit JSON")
|
||||
args = parser.parse_args()
|
||||
|
||||
base = Path(args.path).resolve()
|
||||
results = [analyze_set(path) for path in sorted(base.rglob("*.als"))]
|
||||
|
||||
if args.json:
|
||||
print(json.dumps(results, indent=2))
|
||||
return
|
||||
|
||||
for result in results:
|
||||
print(f"=== {Path(result['file']).name} ===")
|
||||
print(f"tempo: {result['tempo']}")
|
||||
print(f"tracks: {result['track_type_counts']}")
|
||||
print(f"scenes: {result['scene_count']}")
|
||||
print(f"arrangement_length_beats: {result['arrangement_length_beats']}")
|
||||
print(f"automation_event_count: {result['automation_event_count']}")
|
||||
print("locators:")
|
||||
for locator in result["locators"]:
|
||||
print(
|
||||
f" - {locator['time_beats']:>6} {locator['name']}"
|
||||
f" len={locator['section_length_beats']}"
|
||||
)
|
||||
print("top_devices:")
|
||||
for name, count in result["top_devices"].items():
|
||||
print(f" - {name}: {count}")
|
||||
print()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,75 @@
|
||||
"""
|
||||
test_human_feel.py - Tests para HumanFeelEngine
|
||||
T101-T103: Unit tests
|
||||
"""
|
||||
import sys
|
||||
import os
|
||||
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
|
||||
|
||||
import unittest
|
||||
from human_feel import HumanFeelEngine
|
||||
|
||||
|
||||
class TestHumanFeelEngine(unittest.TestCase):
|
||||
"""Tests para HumanFeelEngine"""
|
||||
|
||||
def setUp(self):
|
||||
self.engine = HumanFeelEngine(seed=42)
|
||||
|
||||
def test_timing_variation_range(self):
|
||||
"""T040: Timing variation dentro de rango ±5ms."""
|
||||
notes = [{'pitch': 60, 'start': 0.0, 'velocity': 100}]
|
||||
result = self.engine.apply_timing_variation(notes, amount_ms=5.0)
|
||||
|
||||
for note in result:
|
||||
offset_ms = (note['start'] - 0.0) * 1000
|
||||
self.assertGreaterEqual(offset_ms, -5.0)
|
||||
self.assertLessEqual(offset_ms, 5.0)
|
||||
|
||||
def test_velocity_humanize_variance(self):
|
||||
"""T041: Velocity variation ±5%."""
|
||||
notes = [{'pitch': 60, 'start': 0.0, 'velocity': 100}]
|
||||
result = self.engine.apply_velocity_humanize(notes, variance=0.05)
|
||||
|
||||
for note in result:
|
||||
# Velocity debe estar en rango 95-105
|
||||
self.assertGreaterEqual(note['velocity'], 95)
|
||||
self.assertLessEqual(note['velocity'], 105)
|
||||
|
||||
def test_note_skip_probability(self):
|
||||
"""T042: Probabilidad de skip ~2%."""
|
||||
notes = [{'pitch': 60, 'start': float(i), 'velocity': 100} for i in range(100)]
|
||||
result = self.engine.apply_note_skip_probability(notes, prob=0.02)
|
||||
|
||||
# Con seed=42, debe mantener aprox 98% de notas
|
||||
self.assertGreater(len(result), 90) # No muy estricto por randomness
|
||||
self.assertLess(len(result), 100)
|
||||
|
||||
def test_section_dynamics_scale(self):
|
||||
"""T047-T050: Dinámica por sección."""
|
||||
notes = [{'pitch': 60, 'start': 0.0, 'velocity': 100}]
|
||||
|
||||
# Intro = 70%
|
||||
intro_notes = self.engine.apply_section_dynamics(notes, 'intro')
|
||||
self.assertEqual(intro_notes[0]['velocity'], 70)
|
||||
|
||||
# Drop = 100%
|
||||
drop_notes = self.engine.apply_section_dynamics(notes, 'drop')
|
||||
self.assertEqual(drop_notes[0]['velocity'], 100)
|
||||
|
||||
# Build = 85%
|
||||
build_notes = self.engine.apply_section_dynamics(notes, 'build')
|
||||
self.assertEqual(build_notes[0]['velocity'], 85)
|
||||
|
||||
def test_groove_applies_to_offbeat(self):
|
||||
"""T044-T046: Groove aplica a notas off-beat."""
|
||||
# Nota en off-beat (beat position 0.5)
|
||||
notes = [{'pitch': 60, 'start': 4.5, 'velocity': 100}]
|
||||
result = self.engine.apply_groove(notes, style='shuffle', amount=1.0)
|
||||
|
||||
# Debe tener delay aplicado
|
||||
self.assertGreater(result[0]['start'], 4.5)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
106
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/tests/test_integration.py
Normal file
106
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/tests/test_integration.py
Normal file
@@ -0,0 +1,106 @@
|
||||
"""
|
||||
test_integration.py - Tests de integración end-to-end
|
||||
"""
|
||||
import sys
|
||||
import os
|
||||
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
|
||||
|
||||
import unittest
|
||||
from full_integration import AbletonMCPFullPipeline, generate_complete_track
|
||||
|
||||
|
||||
class TestFullPipeline(unittest.TestCase):
|
||||
"""Tests de integración completa"""
|
||||
|
||||
def setUp(self):
|
||||
self.pipeline = AbletonMCPFullPipeline(seed=42)
|
||||
|
||||
def test_generate_from_vibe_techno(self):
|
||||
"""Test generación desde vibe techno."""
|
||||
result = self.pipeline.generate_from_vibe("dark warehouse techno")
|
||||
|
||||
self.assertEqual(result['genre'], 'techno')
|
||||
self.assertIn('bpm', result)
|
||||
self.assertIn('key', result)
|
||||
self.assertIn('structure', result)
|
||||
self.assertTrue(result['dj_friendly'])
|
||||
|
||||
def test_generate_from_vibe_house(self):
|
||||
"""Test generación desde vibe house."""
|
||||
result = self.pipeline.generate_from_vibe("deep house sunset")
|
||||
|
||||
self.assertEqual(result['genre'], 'house')
|
||||
self.assertIn('bpm', result)
|
||||
self.assertGreaterEqual(result['bpm'], 110)
|
||||
self.assertLessEqual(result['bpm'], 130)
|
||||
|
||||
def test_full_pipeline_applies_human_feel(self):
|
||||
"""Test que human feel está configurado."""
|
||||
result = self.pipeline.generate_from_vibe("techno", apply_full_pipeline=True)
|
||||
|
||||
self.assertIn('human_feel', result)
|
||||
self.assertTrue(result['human_feel']['enabled'])
|
||||
|
||||
def test_full_pipeline_creates_structure(self):
|
||||
"""Test que se crea estructura."""
|
||||
result = self.pipeline.generate_from_vibe("techno")
|
||||
|
||||
self.assertIn('structure', result)
|
||||
self.assertGreater(len(result['structure']), 0)
|
||||
|
||||
def test_full_pipeline_creates_transitions(self):
|
||||
"""Test que se crean transiciones."""
|
||||
result = self.pipeline.generate_from_vibe("techno")
|
||||
|
||||
self.assertIn('transitions', result)
|
||||
self.assertIsInstance(result['transitions'], list)
|
||||
|
||||
def test_full_pipeline_creates_atmos_events(self):
|
||||
"""Test que se detectan gaps y crean atmos."""
|
||||
result = self.pipeline.generate_from_vibe("techno")
|
||||
|
||||
self.assertIn('atmos_events', result)
|
||||
|
||||
def test_full_pipeline_creates_fx_events(self):
|
||||
"""Test que se crean FX automáticos."""
|
||||
result = self.pipeline.generate_from_vibe("techno")
|
||||
|
||||
self.assertIn('fx_events', result)
|
||||
|
||||
def test_full_pipeline_creates_master_chain(self):
|
||||
"""Test que se configura master chain."""
|
||||
result = self.pipeline.generate_from_vibe("techno")
|
||||
|
||||
self.assertIn('master_chain', result)
|
||||
self.assertGreater(len(result['master_chain']), 0)
|
||||
|
||||
def test_generate_complete_track_function(self):
|
||||
"""Test función de conveniencia."""
|
||||
result = generate_complete_track("industrial techno", seed=123)
|
||||
|
||||
self.assertIn('genre', result)
|
||||
self.assertIn('vibe_params', result)
|
||||
|
||||
|
||||
class TestCritiqueAndFix(unittest.TestCase):
|
||||
"""Tests para critique y auto-fix"""
|
||||
|
||||
def setUp(self):
|
||||
self.pipeline = AbletonMCPFullPipeline(seed=42)
|
||||
|
||||
def test_critique_returns_scores(self):
|
||||
"""Test que critique retorna scores."""
|
||||
mock_song = {
|
||||
'sections': [{'name': 'Intro'}, {'name': 'Drop'}],
|
||||
'tracks': [{'name': 'Drums'}, {'name': 'Bass'}]
|
||||
}
|
||||
|
||||
result = self.pipeline.critique_and_fix(mock_song)
|
||||
|
||||
self.assertIn('critique', result)
|
||||
self.assertIn('final_score', result)
|
||||
self.assertIsInstance(result['final_score'], float)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -0,0 +1,77 @@
|
||||
"""
|
||||
test_sample_selector.py - Tests para SampleSelector
|
||||
T101-T103: Unit tests
|
||||
"""
|
||||
import sys
|
||||
import os
|
||||
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
|
||||
|
||||
import unittest
|
||||
from unittest.mock import Mock, MagicMock
|
||||
from sample_selector import SampleSelector, Sample
|
||||
|
||||
|
||||
class TestSampleSelector(unittest.TestCase):
|
||||
"""Tests para SampleSelector"""
|
||||
|
||||
def setUp(self):
|
||||
self.selector = SampleSelector()
|
||||
|
||||
def test_palette_bonus_exact_match(self):
|
||||
"""T026: Bonus 1.4x para folder ancla exacto."""
|
||||
# Simular que tenemos un palette
|
||||
self.selector.set_palette_data({'drums': '/samples/Kicks'})
|
||||
|
||||
# Sample en folder exacto
|
||||
bonus = self.selector._calculate_palette_bonus('/samples/Kicks/kick_01.wav', '/samples/Kicks')
|
||||
self.assertEqual(bonus, 1.4)
|
||||
|
||||
def test_palette_bonus_sibling_folder(self):
|
||||
"""T026: Bonus 1.2x para folder hermano."""
|
||||
self.selector.set_palette_data({'drums': '/samples/Kicks'})
|
||||
|
||||
# Sample en folder hermano
|
||||
bonus = self.selector._calculate_palette_bonus('/samples/Snares/snare_01.wav', '/samples/Kicks')
|
||||
self.assertEqual(bonus, 1.2)
|
||||
|
||||
|
||||
def test_palette_bonus_different_folder(self):
|
||||
"""T026: Penalizacion 0.9x para folder completamente diferente."""
|
||||
self.selector.set_palette_data({'drums': '/Library/Kicks'})
|
||||
|
||||
# Sample en folder completamente diferente (no es hermano)
|
||||
bonus = self.selector._calculate_palette_bonus('/OtherLibrary/Pads/pad.wav', '/Library/Kicks')
|
||||
self.assertEqual(bonus, 0.9)
|
||||
|
||||
def test_role_to_bus_mapping(self):
|
||||
"""Test mapeo de roles a buses."""
|
||||
self.assertEqual(self.selector._role_to_bus('kick'), 'drums')
|
||||
self.assertEqual(self.selector._role_to_bus('bass'), 'bass')
|
||||
self.assertEqual(self.selector._role_to_bus('synth'), 'music')
|
||||
|
||||
def test_fatigue_calculation(self):
|
||||
"""T022: Cálculo correcto de fatiga."""
|
||||
fatigue_data = {
|
||||
'/samples/kick_01.wav': {'kick': {'uses': 5}}
|
||||
}
|
||||
self.selector.set_fatigue_data(fatigue_data)
|
||||
|
||||
# 5 usos = fatiga moderada = 0.50
|
||||
factor = self.selector._get_persistent_fatigue('/samples/kick_01.wav', 'kick')
|
||||
self.assertEqual(factor, 0.50)
|
||||
|
||||
|
||||
class TestSampleValidation(unittest.TestCase):
|
||||
"""Tests para validación de samples"""
|
||||
|
||||
def test_sample_type_detection(self):
|
||||
"""Test detección de tipo de sample."""
|
||||
from audio_analyzer import AudioAnalyzer
|
||||
|
||||
analyzer = AudioAnalyzer(backend="basic")
|
||||
sample_type = analyzer._classify_by_name("Kick_120_BPM.wav")
|
||||
self.assertIn(sample_type.value.lower(), ['kick', 'unknown'])
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
82
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/tofix.md
Normal file
82
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/tofix.md
Normal file
@@ -0,0 +1,82 @@
|
||||
# 🛠️ TOFIX — Pendientes del MCP AbletonMCP_AI
|
||||
|
||||
> Última revisión: 2026-03-22
|
||||
|
||||
---
|
||||
|
||||
## 🔴 Crítico (bloquean funcionalidad)
|
||||
|
||||
_(Ninguno actualmente — todos los errores de runtime F821/F841 han sido corregidos)_
|
||||
|
||||
---
|
||||
|
||||
## 🟠 Alta Prioridad (lint / calidad de código)
|
||||
|
||||
### Archivos con permisos bloqueados por Windows ACL
|
||||
Estos archivos tienen permisos de escritura restringidos por la instalación de Ableton.
|
||||
Para editarlos necesitás **abrir el editor / terminal como Administrador**.
|
||||
|
||||
| Archivo | Línea | Error | Descripción |
|
||||
|---|---|---|---|
|
||||
| `audio_analyzer.py` | 317 | F401 | `struct` importado pero nunca usado |
|
||||
| `role_matcher.py` | 12 | F401 | `random` importado pero nunca usado (se importa inline donde se necesita) |
|
||||
| `role_matcher.py` | 13 | F401 | `typing.Set` importado pero nunca usado |
|
||||
| `sample_manager.py` | 13 | F401 | `os` importado pero nunca usado (reemplazado por `pathlib`) |
|
||||
| `sample_manager.py` | 17 | F401 | `shutil` importado pero nunca usado |
|
||||
| `sample_manager.py` | 19 | F401 | `typing.Set` importado pero nunca usado |
|
||||
| `sample_manager.py` | 24 | F401 | `time` importado pero nunca usado |
|
||||
| `sample_manager.py` | 28/32 | F401 | `audio_analyzer.quick_analyze` importado pero nunca llamado |
|
||||
| `sample_manager.py` | 292 | F841 | `file_hash` asignado pero nunca usado |
|
||||
|
||||
**Cómo fixear:**
|
||||
```powershell
|
||||
# Desde PowerShell como Administrador:
|
||||
icacls "C:\ProgramData\Ableton\Live 12 Suite\Resources\MIDI Remote Scripts\AbletonMCP_AI\MCP_Server\audio_analyzer.py" /grant Users:F
|
||||
icacls "C:\ProgramData\Ableton\Live 12 Suite\Resources\MIDI Remote Scripts\AbletonMCP_AI\MCP_Server\role_matcher.py" /grant Users:F
|
||||
icacls "C:\ProgramData\Ableton\Live 12 Suite\Resources\MIDI Remote Scripts\AbletonMCP_AI\MCP_Server\sample_manager.py" /grant Users:F
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 🟡 Media Prioridad (errores de análisis estático Pyre2)
|
||||
|
||||
> Estos **NO son errores reales en Python** — son limitaciones del motor de análisis Pyre2 con código dinámico. No causan ningún problema en runtime.
|
||||
|
||||
| Tipo | Patrón | Cantidad estimada | Causa real |
|
||||
|---|---|---|---|
|
||||
| `+=` no soportado | `defaultdict` + `int` | ~40+ | Pyre2 no infiere `defaultdict` correctamente |
|
||||
| `*` no soportado | `dict[str, float] * float` | ~10+ | Pyre2 confunde el tipo de retorno de `.get()` |
|
||||
| `in` no soportado | `str in set()` | ~5+ | Pyre2 pierde el tipo de `set` después de asignación |
|
||||
| `round()` overload | `round(x, 3)` | ~6 | Bug conocido de Pyre2 con `ndigits != None` |
|
||||
| `Cannot index` | `dict[Literal[...]]` | ~4 | Pyre2 infiere dict demasiado estricto |
|
||||
|
||||
**Impacto real:** Ninguno. Todos son falsos positivos de inferencia de tipos.
|
||||
|
||||
---
|
||||
|
||||
## 🟢 Baja Prioridad (mejoras arquitecturales)
|
||||
|
||||
| Área | Descripción |
|
||||
|---|---|
|
||||
| `sample_manager.py` | `file_hash` se calcula pero no se usa para detectar cambios reales — actualmente usa `st_mtime`. Podría usarse para comparación más robusta. |
|
||||
| `reference_listener.py` | `_compute_segment_features` referenciado pero el método no está visible en el scope de Pyre2 — verificar que está en la misma clase. |
|
||||
| `reference_listener.py` | `str[::step]` slice con step — Pyre2 reporta error pero es Python válido. Documentar o usar `cast()`. |
|
||||
| `song_generator.py` | Variables `materialized_track_roles` y `event_track_roles` son `set` pero nunca se leen después de ser llenadas — revisar si son necesarias. |
|
||||
| `sample_manager.py` | `SampleType = None` como fallback cuando `audio_analyzer` no se puede importar — podría causar `TypeError` si se usa como clase. |
|
||||
|
||||
---
|
||||
|
||||
## ✅ Ya corregido en esta sesión
|
||||
|
||||
| Archivo | Fix |
|
||||
|---|---|
|
||||
| `song_generator.py:2691` | `kind` → `_kind` (F841) |
|
||||
| `song_generator.py:4144` | `root_note` → `_root_note` (F841) |
|
||||
| `song_generator.py:3265` | `Set[str]` → `set` (F821 — `Set` no importado) |
|
||||
| `song_generator.py:3292` | `Set[str]` → `set` (F821 — `Set` no importado) |
|
||||
| `reference_listener.py:243` | `falling` → `_falling` (F841) |
|
||||
| `reference_listener.py:318` | `smoothed_onset` → `_smoothed_onset` (F841) |
|
||||
| `reference_listener.py:343` | `total_frames` → `_total_frames` (F841) |
|
||||
| `reference_listener.py:2594` | `'Sample'` tipo hint → `Any` (F821 — `Sample` no definido en scope) |
|
||||
| `reference_listener.py:2600` | `'Sample'` tipo hint → `Any` (F821 — `Sample` no definido en scope) |
|
||||
| `opencode.json` | Creado con MCP registrado y todos los permisos en `allow` |
|
||||
222
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/validate_key_detection.py
Normal file
222
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/validate_key_detection.py
Normal file
@@ -0,0 +1,222 @@
|
||||
"""
|
||||
validate_key_detection.py - Script de validación T019
|
||||
Valida que librosa detecta key correctamente en ≥70% de samples armónicos.
|
||||
|
||||
Uso:
|
||||
python validate_key_detection.py <ruta_libreria> [--samples N]
|
||||
"""
|
||||
|
||||
import sys
|
||||
import random
|
||||
import argparse
|
||||
from pathlib import Path
|
||||
from typing import List, Dict, Any
|
||||
import logging
|
||||
|
||||
logging.basicConfig(level=logging.INFO)
|
||||
logger = logging.getLogger("T019-Validation")
|
||||
|
||||
# Importar AudioAnalyzer
|
||||
try:
|
||||
from audio_analyzer import AudioAnalyzer, SampleType
|
||||
ANALYZER_AVAILABLE = True
|
||||
except ImportError:
|
||||
ANALYZER_AVAILABLE = False
|
||||
logger.error("No se pudo importar AudioAnalyzer")
|
||||
sys.exit(1)
|
||||
|
||||
|
||||
def find_harmonic_samples(library_dir: str, max_samples: int = 50) -> List[Path]:
|
||||
"""
|
||||
Busca samples armónicos (bass, pad, synth, chord, lead, etc.) en la librería.
|
||||
"""
|
||||
library_path = Path(library_dir)
|
||||
extensions = {'.wav', '.aif', '.aiff', '.mp3'}
|
||||
|
||||
all_files = []
|
||||
for ext in extensions:
|
||||
all_files.extend(library_path.rglob(f'*{ext}'))
|
||||
all_files.extend(library_path.rglob(f'*{ext.upper()}'))
|
||||
|
||||
# Filtrar por nombre para encontrar samples armónicos probables
|
||||
harmonic_keywords = [
|
||||
'bass', 'pad', 'synth', 'lead', 'chord', 'stab', 'pluck',
|
||||
'arp', 'vocal', 'keys', 'piano', 'guitar', 'strings', 'pad'
|
||||
]
|
||||
|
||||
harmonic_files = []
|
||||
for f in all_files:
|
||||
name_lower = f.stem.lower()
|
||||
if any(kw in name_lower for kw in harmonic_keywords):
|
||||
harmonic_files.append(f)
|
||||
|
||||
# Seleccionar muestra aleatoria
|
||||
if len(harmonic_files) > max_samples:
|
||||
return random.sample(harmonic_files, max_samples)
|
||||
return harmonic_files
|
||||
|
||||
|
||||
def validate_key_detection(samples: List[Path]) -> Dict[str, Any]:
|
||||
"""
|
||||
Valida detección de key en samples.
|
||||
Retorna estadísticas de la validación.
|
||||
"""
|
||||
analyzer = AudioAnalyzer()
|
||||
|
||||
results = {
|
||||
'total': len(samples),
|
||||
'with_key_detected': 0,
|
||||
'with_key_in_name': 0,
|
||||
'matching_keys': 0,
|
||||
'high_confidence': 0, # confidence > 0.6
|
||||
'low_confidence': 0,
|
||||
'by_type': {},
|
||||
'failures': []
|
||||
}
|
||||
|
||||
for sample_path in samples:
|
||||
try:
|
||||
features = analyzer.analyze(str(sample_path))
|
||||
|
||||
# Extraer key del nombre si existe
|
||||
key_from_name = analyzer._extract_key_from_name(sample_path.stem)
|
||||
|
||||
result_entry = {
|
||||
'file': str(sample_path),
|
||||
'detected_key': features.key,
|
||||
'key_confidence': features.key_confidence,
|
||||
'key_from_name': key_from_name,
|
||||
'sample_type': features.sample_type.value,
|
||||
'spectral_centroid': features.spectral_centroid,
|
||||
'is_harmonic': features.is_harmonic
|
||||
}
|
||||
|
||||
# Contar key detectada
|
||||
if features.key:
|
||||
results['with_key_detected'] += 1
|
||||
|
||||
# Alta confianza
|
||||
if features.key_confidence > 0.6:
|
||||
results['high_confidence'] += 1
|
||||
else:
|
||||
results['low_confidence'] += 1
|
||||
|
||||
# Key en nombre
|
||||
if key_from_name:
|
||||
results['with_key_in_name'] += 1
|
||||
|
||||
# Comparar si coinciden
|
||||
if features.key and features.key.lower() == key_from_name.lower():
|
||||
results['matching_keys'] += 1
|
||||
result_entry['match'] = True
|
||||
else:
|
||||
result_entry['match'] = False
|
||||
|
||||
# Por tipo
|
||||
sample_type = features.sample_type.value
|
||||
if sample_type not in results['by_type']:
|
||||
results['by_type'][sample_type] = {'total': 0, 'with_key': 0}
|
||||
results['by_type'][sample_type]['total'] += 1
|
||||
if features.key:
|
||||
results['by_type'][sample_type]['with_key'] += 1
|
||||
|
||||
# Si no detectó key en sample armónico, es un "failure"
|
||||
if features.is_harmonic and not features.key:
|
||||
results['failures'].append(result_entry)
|
||||
|
||||
logger.info(f"✓ {sample_path.stem}: key={features.key} "
|
||||
f"(conf={features.key_confidence:.2f}, "
|
||||
f"type={features.sample_type.value})")
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"✗ Error analizando {sample_path}: {e}")
|
||||
results['failures'].append({'file': str(sample_path), 'error': str(e)})
|
||||
|
||||
return results
|
||||
|
||||
|
||||
def print_report(results: Dict[str, Any]):
|
||||
"""Imprime reporte de validación T019."""
|
||||
total = results['total']
|
||||
|
||||
print("\n" + "=" * 60)
|
||||
print("📊 REPORTE DE VALIDACIÓN T019: Key Detection con librosa")
|
||||
print("=" * 60)
|
||||
|
||||
print(f"\n📁 Total samples analizados: {total}")
|
||||
print(f"🔑 Keys detectadas: {results['with_key_detected']} "
|
||||
f"({results['with_key_detected'] / total * 100:.1f}%)")
|
||||
print(f"📋 Keys en nombre de archivo: {results['with_key_in_name']}")
|
||||
print(f"✅ Keys coincidentes (detectada vs nombre): {results['matching_keys']}")
|
||||
|
||||
print(f"\n📈 Distribución de confianza:")
|
||||
print(f" Alta (>0.6): {results['high_confidence']} "
|
||||
f"({results['high_confidence'] / total * 100:.1f}%)")
|
||||
print(f" Baja (≤0.6): {results['low_confidence']} "
|
||||
f"({results['low_confidence'] / total * 100:.1f}%)")
|
||||
|
||||
print(f"\n📊 Por tipo de sample:")
|
||||
for sample_type, stats in sorted(results['by_type'].items()):
|
||||
rate = stats['with_key'] / stats['total'] * 100 if stats['total'] > 0 else 0
|
||||
print(f" {sample_type}: {stats['with_key']}/{stats['total']} con key ({rate:.1f}%)")
|
||||
|
||||
# Verificar KPI T019
|
||||
detection_rate = results['with_key_detected'] / total * 100 if total > 0 else 0
|
||||
print(f"\n🎯 KPI T019: Detección de key en ≥70% de samples")
|
||||
print(f" Resultado: {detection_rate:.1f}%")
|
||||
if detection_rate >= 70:
|
||||
print(f" ✅ CUMPLE el objetivo de 70%")
|
||||
else:
|
||||
print(f" ❌ NO CUMPLE el objetivo (necesita mejorar)")
|
||||
|
||||
if results['failures']:
|
||||
print(f"\n⚠️ {len(results['failures'])} samples armónicos sin key detectada:")
|
||||
for f in results['failures'][:10]: # Mostrar primeros 10
|
||||
print(f" - {Path(f['file']).name}")
|
||||
|
||||
print("\n" + "=" * 60)
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(
|
||||
description='Validar detección de key con librosa (T019)'
|
||||
)
|
||||
parser.add_argument(
|
||||
'library_dir',
|
||||
help='Ruta a la librería de samples'
|
||||
)
|
||||
parser.add_argument(
|
||||
'--samples', '-n',
|
||||
type=int,
|
||||
default=50,
|
||||
help='Número de samples a analizar (default: 50)'
|
||||
)
|
||||
parser.add_argument(
|
||||
'--seed',
|
||||
type=int,
|
||||
default=42,
|
||||
help='Seed para reproducibilidad (default: 42)'
|
||||
)
|
||||
|
||||
args = parser.parse_args()
|
||||
|
||||
random.seed(args.seed)
|
||||
|
||||
print(f"🔍 Buscando samples armónicos en: {args.library_dir}")
|
||||
samples = find_harmonic_samples(args.library_dir, args.samples)
|
||||
|
||||
if not samples:
|
||||
logger.error("No se encontraron samples armónicos")
|
||||
sys.exit(1)
|
||||
|
||||
print(f"🎵 Analizando {len(samples)} samples...")
|
||||
results = validate_key_detection(samples)
|
||||
print_report(results)
|
||||
|
||||
# Exit code según KPI
|
||||
detection_rate = results['with_key_detected'] / results['total'] * 100
|
||||
sys.exit(0 if detection_rate >= 70 else 1)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
374
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/validation_system_fix.py
Normal file
374
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/validation_system_fix.py
Normal file
@@ -0,0 +1,374 @@
|
||||
"""
|
||||
validation_system_fix.py - Sistema de validación mejorado
|
||||
T105-T106: Validation System Fix
|
||||
|
||||
Validaciones críticas:
|
||||
- Clips vacíos (silencio real)
|
||||
- Audio files corruptos/missing
|
||||
- Key conflict grave (disonancia)
|
||||
- Samples duplicados accidentalmente
|
||||
- Phasing entre capas de drums
|
||||
"""
|
||||
import logging
|
||||
from typing import Dict, Any, List, Optional, Tuple
|
||||
from pathlib import Path
|
||||
from dataclasses import dataclass
|
||||
|
||||
logger = logging.getLogger("ValidationSystemFix")
|
||||
|
||||
|
||||
@dataclass
|
||||
class ValidationIssue:
|
||||
"""Representa un problema de validación"""
|
||||
type: str
|
||||
severity: str # 'error', 'warning', 'info'
|
||||
track: str
|
||||
clip: str
|
||||
message: str
|
||||
suggestion: str
|
||||
auto_fixable: bool = False
|
||||
|
||||
|
||||
class ValidationSystemFixer:
|
||||
"""T105-T106: Sistema de validación completo"""
|
||||
|
||||
def __init__(self):
|
||||
self.issues: List[ValidationIssue] = []
|
||||
self.validation_rules = {
|
||||
'min_clip_duration': 0.5, # beats
|
||||
'max_silence_threshold': -60.0, # dB
|
||||
'key_conflict_threshold': 3, # semitones
|
||||
'duplicate_tolerance_seconds': 0.5,
|
||||
}
|
||||
|
||||
def validate_clips(self, clips_data: List[Dict]) -> List[ValidationIssue]:
|
||||
"""
|
||||
T105: Valida clips de audio.
|
||||
|
||||
Checks:
|
||||
- Clip vacío (silencio)
|
||||
- File missing/corrupt
|
||||
- Duración inválida
|
||||
"""
|
||||
issues = []
|
||||
|
||||
for clip in clips_data:
|
||||
track_name = clip.get('track_name', 'Unknown')
|
||||
clip_name = clip.get('name', 'Unknown')
|
||||
file_path = clip.get('file_path', '')
|
||||
|
||||
# 1. Check file exists
|
||||
if file_path and not Path(file_path).exists():
|
||||
issues.append(ValidationIssue(
|
||||
type='missing_file',
|
||||
severity='error',
|
||||
track=track_name,
|
||||
clip=clip_name,
|
||||
message=f"Audio file not found: {file_path}",
|
||||
suggestion="Rescan library or replace sample",
|
||||
auto_fixable=False
|
||||
))
|
||||
|
||||
# 2. Check duration
|
||||
duration = clip.get('duration', 0)
|
||||
if duration < self.validation_rules['min_clip_duration']:
|
||||
issues.append(ValidationIssue(
|
||||
type='too_short',
|
||||
severity='warning',
|
||||
track=track_name,
|
||||
clip=clip_name,
|
||||
message=f"Clip too short: {duration:.2f} beats",
|
||||
suggestion="Extend or replace sample",
|
||||
auto_fixable=False
|
||||
))
|
||||
|
||||
# 3. Check loop points
|
||||
loop_start = clip.get('loop_start', 0)
|
||||
loop_end = clip.get('loop_end', duration)
|
||||
if loop_end <= loop_start:
|
||||
issues.append(ValidationIssue(
|
||||
type='invalid_loop',
|
||||
severity='error',
|
||||
track=track_name,
|
||||
clip=clip_name,
|
||||
message="Loop end before loop start",
|
||||
suggestion="Fix loop points",
|
||||
auto_fixable=True
|
||||
))
|
||||
|
||||
return issues
|
||||
|
||||
def validate_key_conflicts(self, tracks_data: List[Dict], target_key: str) -> List[ValidationIssue]:
|
||||
"""
|
||||
T106: Detecta conflictos armónicos graves.
|
||||
|
||||
Args:
|
||||
tracks_data: Tracks con información de key
|
||||
target_key: Key objetivo del track
|
||||
|
||||
Returns:
|
||||
Lista de conflictos detectados
|
||||
"""
|
||||
issues = []
|
||||
|
||||
# Mapeo de notas a índices
|
||||
NOTE_MAP = {
|
||||
'C': 0, 'C#': 1, 'Db': 1, 'D': 2, 'D#': 3, 'Eb': 3,
|
||||
'E': 4, 'F': 5, 'F#': 6, 'Gb': 6, 'G': 7, 'G#': 8,
|
||||
'Ab': 8, 'A': 9, 'A#': 10, 'Bb': 10, 'B': 11
|
||||
}
|
||||
|
||||
def get_semitone_distance(key1: str, key2: str) -> int:
|
||||
"""Calcula distancia en semitonos entre keys."""
|
||||
# Extraer root note
|
||||
root1 = key1.replace('m', '').replace('M', '')
|
||||
root2 = key2.replace('m', '').replace('M', '')
|
||||
|
||||
# Check minor flag
|
||||
is_minor1 = 'm' in key1.lower() and 'M' not in key1
|
||||
is_minor2 = 'm' in key2.lower() and 'M' not in key2
|
||||
|
||||
# Diferentes modos = potencial conflicto
|
||||
if is_minor1 != is_minor2:
|
||||
return 6 # Máximo conflicto
|
||||
|
||||
idx1 = NOTE_MAP.get(root1, 0)
|
||||
idx2 = NOTE_MAP.get(root2, 0)
|
||||
|
||||
distance = abs(idx1 - idx2)
|
||||
return min(distance, 12 - distance) # Distancia circular
|
||||
|
||||
target_root = target_key.replace('m', '').replace('M', '')
|
||||
|
||||
for track in tracks_data:
|
||||
track_name = track.get('name', 'Unknown')
|
||||
track_key = track.get('key', '')
|
||||
|
||||
if not track_key:
|
||||
continue
|
||||
|
||||
distance = get_semitone_distance(target_key, track_key)
|
||||
|
||||
# Conflicto grave: > 3 semitonos
|
||||
if distance >= 4:
|
||||
issues.append(ValidationIssue(
|
||||
type='key_conflict',
|
||||
severity='error',
|
||||
track=track_name,
|
||||
clip='',
|
||||
message=f"Severe key conflict: {track_key} vs {target_key} ({distance} semitones)",
|
||||
suggestion=f"Transpose to {target_key} or replace sample",
|
||||
auto_fixable=True
|
||||
))
|
||||
elif distance >= 2:
|
||||
issues.append(ValidationIssue(
|
||||
type='key_variation',
|
||||
severity='warning',
|
||||
track=track_name,
|
||||
clip='',
|
||||
message=f"Key variation detected: {track_key} vs {target_key}",
|
||||
suggestion="Check if harmonic variation is intentional",
|
||||
auto_fixable=False
|
||||
))
|
||||
|
||||
return issues
|
||||
|
||||
def validate_duplicates(self, clips_data: List[Dict]) -> List[ValidationIssue]:
|
||||
"""Detecta samples duplicados accidentalmente."""
|
||||
issues = []
|
||||
|
||||
# Agrupar por file_path
|
||||
file_usage = {}
|
||||
for clip in clips_data:
|
||||
file_path = clip.get('file_path', '')
|
||||
if not file_path:
|
||||
continue
|
||||
|
||||
if file_path not in file_usage:
|
||||
file_usage[file_path] = []
|
||||
file_usage[file_path].append(clip)
|
||||
|
||||
# Detectar duplicados
|
||||
for file_path, clips in file_usage.items():
|
||||
if len(clips) > 1:
|
||||
# Es duplicado si están en tracks diferentes
|
||||
tracks = set(c.get('track_name') for c in clips)
|
||||
if len(tracks) > 1:
|
||||
issues.append(ValidationIssue(
|
||||
type='duplicate_sample',
|
||||
severity='warning',
|
||||
track=', '.join(tracks),
|
||||
clip=Path(file_path).name,
|
||||
message=f"Sample used in {len(tracks)} different tracks",
|
||||
suggestion="Consider if intentional layering or accidental duplicate",
|
||||
auto_fixable=False
|
||||
))
|
||||
|
||||
return issues
|
||||
|
||||
def validate_gain_staging(self, tracks_data: List[Dict]) -> List[ValidationIssue]:
|
||||
"""Valida niveles de gain staging."""
|
||||
issues = []
|
||||
|
||||
for track in tracks_data:
|
||||
track_name = track.get('name', 'Unknown')
|
||||
volume = track.get('volume', 0.85)
|
||||
|
||||
# Clipping prevention
|
||||
if volume > 0.95:
|
||||
issues.append(ValidationIssue(
|
||||
type='high_volume',
|
||||
severity='warning',
|
||||
track=track_name,
|
||||
clip='',
|
||||
message=f"Volume too high: {volume:.2f}",
|
||||
suggestion="Reduce to prevent clipping",
|
||||
auto_fixable=True
|
||||
))
|
||||
|
||||
# Too quiet
|
||||
if volume < 0.1 and track.get('role') not in ['atmos', 'texture']:
|
||||
issues.append(ValidationIssue(
|
||||
type='low_volume',
|
||||
severity='info',
|
||||
track=track_name,
|
||||
clip='',
|
||||
message=f"Volume very low: {volume:.2f}",
|
||||
suggestion="Check if track is audible",
|
||||
auto_fixable=False
|
||||
))
|
||||
|
||||
return issues
|
||||
|
||||
def run_full_validation(self, set_data: Dict) -> Dict[str, Any]:
|
||||
"""
|
||||
Ejecuta validación completa del set.
|
||||
|
||||
Args:
|
||||
set_data: Datos completos del set de Ableton
|
||||
|
||||
Returns:
|
||||
Reporte de validación completo
|
||||
"""
|
||||
all_issues = []
|
||||
|
||||
tracks = set_data.get('tracks', [])
|
||||
clips = set_data.get('clips', [])
|
||||
target_key = set_data.get('key', 'Am')
|
||||
|
||||
# 1. Validar clips
|
||||
clip_issues = self.validate_clips(clips)
|
||||
all_issues.extend(clip_issues)
|
||||
|
||||
# 2. Validar key conflicts
|
||||
key_issues = self.validate_key_conflicts(tracks, target_key)
|
||||
all_issues.extend(key_issues)
|
||||
|
||||
# 3. Validar duplicados
|
||||
dup_issues = self.validate_duplicates(clips)
|
||||
all_issues.extend(dup_issues)
|
||||
|
||||
# 4. Validar gain staging
|
||||
gain_issues = self.validate_gain_staging(tracks)
|
||||
all_issues.extend(gain_issues)
|
||||
|
||||
# Clasificar por severidad
|
||||
errors = [i for i in all_issues if i.severity == 'error']
|
||||
warnings = [i for i in all_issues if i.severity == 'warning']
|
||||
info = [i for i in all_issues if i.severity == 'info']
|
||||
auto_fixable = [i for i in all_issues if i.auto_fixable]
|
||||
|
||||
return {
|
||||
'valid': len(errors) == 0,
|
||||
'summary': {
|
||||
'total_issues': len(all_issues),
|
||||
'errors': len(errors),
|
||||
'warnings': len(warnings),
|
||||
'info': len(info),
|
||||
'auto_fixable': len(auto_fixable)
|
||||
},
|
||||
'issues': [
|
||||
{
|
||||
'type': i.type,
|
||||
'severity': i.severity,
|
||||
'track': i.track,
|
||||
'clip': i.clip,
|
||||
'message': i.message,
|
||||
'suggestion': i.suggestion,
|
||||
'auto_fixable': i.auto_fixable
|
||||
}
|
||||
for i in all_issues
|
||||
],
|
||||
'auto_fixes_available': [
|
||||
{'type': i.type, 'track': i.track}
|
||||
for i in auto_fixable
|
||||
]
|
||||
}
|
||||
|
||||
def apply_auto_fixes(self, set_data: Dict, ableton_connection) -> Dict:
|
||||
"""Aplica fixes automáticos para issues auto-fixable."""
|
||||
fixes_applied = []
|
||||
fixes_failed = []
|
||||
|
||||
issues = self.run_full_validation(set_data)
|
||||
|
||||
for issue_data in issues.get('issues', []):
|
||||
if not issue_data.get('auto_fixable'):
|
||||
continue
|
||||
|
||||
issue_type = issue_data.get('type')
|
||||
track = issue_data.get('track')
|
||||
|
||||
try:
|
||||
if issue_type == 'invalid_loop':
|
||||
# Fix loop points
|
||||
self._fix_loop_points(ableton_connection, track, issue_data.get('clip'))
|
||||
fixes_applied.append({'type': 'loop_points', 'track': track})
|
||||
|
||||
elif issue_type == 'high_volume':
|
||||
# Reduce volume
|
||||
self._adjust_volume(ableton_connection, track, 0.85)
|
||||
fixes_applied.append({'type': 'volume', 'track': track})
|
||||
|
||||
elif issue_type == 'key_conflict':
|
||||
# Suggest transpose
|
||||
fixes_applied.append({'type': 'key_transpose_suggested', 'track': track})
|
||||
|
||||
except Exception as e:
|
||||
fixes_failed.append({'type': issue_type, 'track': track, 'error': str(e)})
|
||||
|
||||
return {
|
||||
'fixes_applied': fixes_applied,
|
||||
'fixes_failed': fixes_failed,
|
||||
'total_fixed': len(fixes_applied)
|
||||
}
|
||||
|
||||
def _fix_loop_points(self, ableton_connection, track: str, clip: str):
|
||||
"""Corrige loop points inválidos."""
|
||||
cmd = {
|
||||
'command': 'reset_loop_points',
|
||||
'track': track,
|
||||
'clip': clip
|
||||
}
|
||||
ableton_connection.send_command(cmd)
|
||||
|
||||
def _adjust_volume(self, ableton_connection, track: str, level: float):
|
||||
"""Ajusta volumen de track."""
|
||||
cmd = {
|
||||
'command': 'set_track_volume',
|
||||
'track': track,
|
||||
'volume': level
|
||||
}
|
||||
ableton_connection.send_command(cmd)
|
||||
|
||||
|
||||
# Instancia global
|
||||
_validation_fixer: Optional[ValidationSystemFixer] = None
|
||||
|
||||
|
||||
def get_validation_fixer() -> ValidationSystemFixer:
|
||||
"""Obtiene instancia global del validador."""
|
||||
global _validation_fixer
|
||||
if _validation_fixer is None:
|
||||
_validation_fixer = ValidationSystemFixer()
|
||||
return _validation_fixer
|
||||
318
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/vector_manager.py
Normal file
318
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/vector_manager.py
Normal file
@@ -0,0 +1,318 @@
|
||||
import os
|
||||
import json
|
||||
import logging
|
||||
from pathlib import Path
|
||||
from typing import List, Dict, Tuple, Optional, Any
|
||||
from concurrent.futures import ThreadPoolExecutor, as_completed
|
||||
|
||||
try:
|
||||
from sentence_transformers import SentenceTransformer
|
||||
from sklearn.metrics.pairwise import cosine_similarity
|
||||
import numpy as np
|
||||
HAS_ML = True
|
||||
except ImportError:
|
||||
HAS_ML = False
|
||||
|
||||
try:
|
||||
import torch
|
||||
HAS_TORCH = True
|
||||
except ImportError:
|
||||
torch = None
|
||||
HAS_TORCH = False
|
||||
|
||||
# Importar audio_analyzer para análisis espectral (T016)
|
||||
try:
|
||||
from audio_analyzer import AudioAnalyzer, get_analyzer
|
||||
HAS_ANALYZER = True
|
||||
except ImportError:
|
||||
HAS_ANALYZER = False
|
||||
|
||||
logger = logging.getLogger("VectorManager")
|
||||
logging.basicConfig(level=logging.INFO)
|
||||
IGNORED_SEGMENTS = {"(extra)", ".sample_cache", "__pycache__", "documentation", "installer"}
|
||||
|
||||
class VectorManager:
|
||||
_shared_model = None
|
||||
|
||||
def __init__(self, library_dir: str, skip_audio_analysis: bool = False):
|
||||
self.library_dir = Path(library_dir)
|
||||
self.index_file = self.library_dir / ".sample_embeddings.json"
|
||||
self.skip_audio_analysis = skip_audio_analysis
|
||||
self.cpu_threads = max(1, (os.cpu_count() or 2) // 2)
|
||||
|
||||
self.model = None
|
||||
self.embeddings = []
|
||||
self.metadata = []
|
||||
|
||||
# Inicializar analizador de audio si está disponible (T016)
|
||||
self.analyzer = None
|
||||
if HAS_ANALYZER and not skip_audio_analysis:
|
||||
try:
|
||||
self.analyzer = get_analyzer()
|
||||
logger.info("✓ AudioAnalyzer inicializado para análisis espectral")
|
||||
except Exception as e:
|
||||
logger.warning(f"No se pudo inicializar AudioAnalyzer: {e}")
|
||||
|
||||
if HAS_ML:
|
||||
try:
|
||||
os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
|
||||
if HAS_TORCH:
|
||||
try:
|
||||
torch.set_num_threads(self.cpu_threads)
|
||||
except Exception:
|
||||
pass
|
||||
try:
|
||||
torch.set_num_interop_threads(max(1, self.cpu_threads // 2))
|
||||
except Exception:
|
||||
pass
|
||||
if VectorManager._shared_model is None:
|
||||
logger.info("Loading sentence-transformers model (all-MiniLM-L6-v2) with %d CPU threads...", self.cpu_threads)
|
||||
try:
|
||||
VectorManager._shared_model = SentenceTransformer('all-MiniLM-L6-v2', local_files_only=True)
|
||||
except Exception:
|
||||
VectorManager._shared_model = SentenceTransformer('all-MiniLM-L6-v2')
|
||||
self.model = VectorManager._shared_model
|
||||
except Exception as e:
|
||||
logger.error(f"Failed to load embedding model: {e}")
|
||||
|
||||
self._load_or_build_index()
|
||||
|
||||
def _load_or_build_index(self):
|
||||
if self.index_file.exists():
|
||||
logger.info("Loading existing vector index...")
|
||||
try:
|
||||
with open(self.index_file, 'r', encoding='utf-8') as f:
|
||||
data = json.load(f)
|
||||
self.metadata = data.get('metadata', [])
|
||||
|
||||
if HAS_ML and 'embeddings' in data:
|
||||
self.embeddings = np.array(data['embeddings'])
|
||||
else:
|
||||
logger.warning("No embeddings found in loaded index.")
|
||||
except Exception as e:
|
||||
logger.error(f"Failed to load index: {e}")
|
||||
self._build_index()
|
||||
else:
|
||||
self._build_index()
|
||||
|
||||
def _build_index(self):
|
||||
logger.info(f"Scanning library {self.library_dir} for new embeddings...")
|
||||
logger.info(f"Audio analysis: {'enabled' if self.analyzer else 'disabled (T016)'}")
|
||||
extensions = {'.wav', '.aif', '.aiff', '.mp3', '.flac'}
|
||||
|
||||
files_to_process = []
|
||||
for ext in extensions:
|
||||
files_to_process.extend(self.library_dir.rglob('*' + ext))
|
||||
files_to_process.extend(self.library_dir.rglob('*' + ext.upper()))
|
||||
|
||||
if not files_to_process:
|
||||
logger.warning(f"No audio files found in {self.library_dir} to embed.")
|
||||
return
|
||||
|
||||
texts_to_embed = []
|
||||
self.metadata = []
|
||||
unique_files = sorted(
|
||||
{
|
||||
f.resolve() for f in files_to_process
|
||||
if f.is_file() and not any(part.strip().lower() in IGNORED_SEGMENTS for part in f.parts)
|
||||
},
|
||||
key=lambda item: str(item).lower(),
|
||||
)
|
||||
total_files = len(unique_files)
|
||||
for i, f in enumerate(unique_files):
|
||||
# Clean up the name for better semantic understanding
|
||||
name = f.stem
|
||||
clean_name = name.replace('_', ' ').replace('-', ' ').lower()
|
||||
|
||||
# Use relative path as part of the context since folders represent duration and type
|
||||
try:
|
||||
rel_path = f.relative_to(self.library_dir)
|
||||
parts = rel_path.parts[:-1]
|
||||
path_context = " ".join(parts).lower()
|
||||
except ValueError:
|
||||
path_context = ""
|
||||
|
||||
# T016: Análisis espectral durante indexado
|
||||
spectral_features = self._analyze_sample_spectral(f)
|
||||
|
||||
# T018: Mejorar text embedding con info espectral
|
||||
brightness_tag = self._get_brightness_tag(spectral_features.get('spectral_centroid', 5000))
|
||||
harmonic_tag = "harmonic=yes" if spectral_features.get('is_harmonic') else "harmonic=no"
|
||||
key_tag = f"key={spectral_features.get('key', 'unknown')}"
|
||||
bpm_tag = f"bpm={int(round(float(spectral_features.get('bpm') or 0.0)))}" if spectral_features.get('bpm') else "bpm=unknown"
|
||||
type_tag = f"type={spectral_features.get('sample_type', 'unknown')}"
|
||||
|
||||
description = f"{clean_name} {path_context} {type_tag} {brightness_tag} {harmonic_tag} {key_tag} {bpm_tag}"
|
||||
texts_to_embed.append(description)
|
||||
|
||||
# T020: Agregar campo is_tonal
|
||||
sample_type = spectral_features.get('sample_type', 'unknown')
|
||||
is_tonal = self._is_tonal_sample(sample_type)
|
||||
spectral_features['is_tonal'] = is_tonal
|
||||
|
||||
self.metadata.append({
|
||||
'path': str(f),
|
||||
'name': name,
|
||||
'description': description,
|
||||
'spectral_features': spectral_features # T016: Guardar features espectrales
|
||||
})
|
||||
|
||||
# Log de progreso cada 50 archivos
|
||||
if (i + 1) % 50 == 0:
|
||||
logger.info(f"Procesados {i + 1}/{total_files} samples...")
|
||||
|
||||
if HAS_ML and self.model:
|
||||
logger.info(f"Generating vectors for {len(texts_to_embed)} samples. This might take a moment...")
|
||||
embeddings = self.model.encode(texts_to_embed, show_progress_bar=False)
|
||||
self.embeddings = embeddings
|
||||
|
||||
# Save the vectors
|
||||
with open(self.index_file, 'w', encoding='utf-8') as f:
|
||||
json.dump({
|
||||
'metadata': self.metadata,
|
||||
'embeddings': embeddings.tolist()
|
||||
}, f)
|
||||
logger.info(f"✓ Saved {len(self.metadata)} embeddings with spectral analysis to {self.index_file}")
|
||||
else:
|
||||
logger.error("ML libraries not installed. Run 'pip install sentence-transformers scikit-learn numpy'")
|
||||
|
||||
def _analyze_sample_spectral(self, file_path: Path) -> Dict[str, Any]:
|
||||
"""
|
||||
T016: Análisis espectral de un sample usando AudioAnalyzer.
|
||||
Retorna dict con key, spectral_centroid, is_harmonic, etc.
|
||||
"""
|
||||
if not self.analyzer:
|
||||
return {
|
||||
'key': None,
|
||||
'key_confidence': 0.0,
|
||||
'spectral_centroid': 5000.0,
|
||||
'rms_energy': 0.5,
|
||||
'is_harmonic': False,
|
||||
'is_percussive': True,
|
||||
'sample_type': 'unknown'
|
||||
}
|
||||
|
||||
try:
|
||||
features = self.analyzer.analyze(str(file_path))
|
||||
return {
|
||||
'key': features.key,
|
||||
'key_confidence': features.key_confidence,
|
||||
'spectral_centroid': features.spectral_centroid,
|
||||
'spectral_rolloff': features.spectral_rolloff,
|
||||
'rms_energy': features.rms_energy,
|
||||
'is_harmonic': features.is_harmonic,
|
||||
'is_percussive': features.is_percussive,
|
||||
'sample_type': features.sample_type.value,
|
||||
'duration': features.duration,
|
||||
'bpm': features.bpm
|
||||
}
|
||||
except Exception as e:
|
||||
logger.warning(f"Error analizando {file_path}: {e}")
|
||||
return {
|
||||
'key': None,
|
||||
'key_confidence': 0.0,
|
||||
'spectral_centroid': 5000.0,
|
||||
'rms_energy': 0.5,
|
||||
'is_harmonic': False,
|
||||
'is_percussive': True,
|
||||
'sample_type': 'unknown'
|
||||
}
|
||||
|
||||
def _get_brightness_tag(self, spectral_centroid: float) -> str:
|
||||
"""
|
||||
T018: Generar tag de brillo espectral para el embedding de texto.
|
||||
"""
|
||||
if spectral_centroid < 1000:
|
||||
return "brightness=dark"
|
||||
elif spectral_centroid < 3000:
|
||||
return "brightness=warm"
|
||||
elif spectral_centroid < 6000:
|
||||
return "brightness=neutral"
|
||||
elif spectral_centroid < 10000:
|
||||
return "brightness=bright"
|
||||
else:
|
||||
return "brightness=harsh"
|
||||
|
||||
def _is_tonal_sample(self, sample_type: str) -> bool:
|
||||
"""
|
||||
T020: Determinar si un tipo de sample es tonal (armónico).
|
||||
"""
|
||||
tonal_types = {'bass', 'synth', 'pad', 'lead', 'pluck', 'arp', 'chord', 'stab', 'vocal'}
|
||||
return any(t in sample_type.lower() for t in tonal_types)
|
||||
|
||||
def get_sample_spectral_features(self, file_path: str) -> Optional[Dict[str, Any]]:
|
||||
"""
|
||||
Obtener features espectrales de un sample específico del índice.
|
||||
"""
|
||||
for meta in self.metadata:
|
||||
if meta['path'] == file_path:
|
||||
return meta.get('spectral_features')
|
||||
return None
|
||||
|
||||
def get_samples_by_key(self, key: str) -> List[Dict]:
|
||||
"""
|
||||
Retornar todos los samples que coinciden con una key específica.
|
||||
"""
|
||||
results = []
|
||||
for meta in self.metadata:
|
||||
spectral = meta.get('spectral_features', {})
|
||||
if spectral.get('key') == key:
|
||||
results.append(meta)
|
||||
return results
|
||||
|
||||
def semantic_search(self, query: str, limit: int = 5) -> List[Dict]:
|
||||
"""
|
||||
Returns a list of metadata dicts sorted by semantic relevance down to the limit.
|
||||
Fallback to basic substring matching if ML is unavailable.
|
||||
"""
|
||||
if not HAS_ML or self.model is None or len(self.embeddings) == 0:
|
||||
logger.warning("ML unavailable, falling back to substring search.")
|
||||
return self._fallback_search(query, limit)
|
||||
|
||||
logger.info(f"Performing semantic search for: '{query}'")
|
||||
query_emb = self.model.encode([query], show_progress_bar=False)
|
||||
|
||||
# Calculate cosine similarity between query and all stored embeddings
|
||||
similarities = cosine_similarity(query_emb, self.embeddings)[0]
|
||||
|
||||
# Get top indices
|
||||
top_indices = np.argsort(similarities)[::-1][:limit]
|
||||
|
||||
results = []
|
||||
for idx in top_indices:
|
||||
score = float(similarities[idx])
|
||||
meta = self.metadata[idx].copy()
|
||||
meta['score'] = score
|
||||
results.append(meta)
|
||||
|
||||
return results
|
||||
|
||||
def _fallback_search(self, query: str, limit: int = 5) -> List[Dict]:
|
||||
query = query.lower()
|
||||
scored = []
|
||||
for m in self.metadata:
|
||||
score = 0
|
||||
if query in m['name'].lower():
|
||||
score += 10
|
||||
if query in m['description'].lower():
|
||||
score += 5
|
||||
|
||||
if score > 0:
|
||||
scored.append((score, m))
|
||||
|
||||
scored.sort(key=lambda x: x[0], reverse=True)
|
||||
return [m for s, m in scored[:limit]]
|
||||
|
||||
if __name__ == "__main__":
|
||||
import sys
|
||||
if len(sys.argv) > 1:
|
||||
path = sys.argv[1]
|
||||
vm = VectorManager(path)
|
||||
if len(sys.argv) > 2:
|
||||
query = sys.argv[2]
|
||||
res = vm.semantic_search(query)
|
||||
print("Search Results for", query)
|
||||
for r in res:
|
||||
print(r['score'], r['name'], r['path'])
|
||||
else:
|
||||
print("Usage: python vector_manager.py <library_dir> [search_query]")
|
||||
264
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/zai_judges.py
Normal file
264
AbletonMCP_AI/AbletonMCP_AI/MCP_Server/zai_judges.py
Normal file
@@ -0,0 +1,264 @@
|
||||
"""
|
||||
zai_judges.py - Multi-judge decision layer using Z.ai Anthropic-compatible API.
|
||||
|
||||
Used to rank palette candidates before generation so the system chooses a
|
||||
coherent sonic direction instead of mixing unrelated local material.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import logging
|
||||
import os
|
||||
import re
|
||||
from concurrent.futures import ThreadPoolExecutor, as_completed
|
||||
from typing import Any, Dict, List, Optional
|
||||
from urllib.error import HTTPError, URLError
|
||||
from urllib.request import Request, urlopen
|
||||
|
||||
logger = logging.getLogger("ZAIJudges")
|
||||
|
||||
|
||||
def _resolve_messages_url() -> str:
|
||||
base = str(os.getenv("ANTHROPIC_BASE_URL", "https://api.z.ai/api/anthropic")).strip().rstrip("/")
|
||||
if base.endswith("/v1/messages"):
|
||||
return base
|
||||
if base.endswith("/v1"):
|
||||
return base + "/messages"
|
||||
return base + "/v1/messages"
|
||||
|
||||
|
||||
def _extract_json_object(text: str) -> Dict[str, Any]:
|
||||
candidate = str(text or "").strip()
|
||||
if not candidate:
|
||||
return {}
|
||||
try:
|
||||
return json.loads(candidate)
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
match = re.search(r"\{.*\}", candidate, re.DOTALL)
|
||||
if not match:
|
||||
return {}
|
||||
try:
|
||||
return json.loads(match.group(0))
|
||||
except Exception:
|
||||
return {}
|
||||
|
||||
|
||||
class ZAIJudgePanel:
|
||||
def __init__(self) -> None:
|
||||
self.base_url = _resolve_messages_url()
|
||||
self.auth_token = (
|
||||
os.getenv("ANTHROPIC_AUTH_TOKEN")
|
||||
or os.getenv("ZAI_API_KEY")
|
||||
or os.getenv("ANTHROPIC_API_KEY")
|
||||
or ""
|
||||
).strip()
|
||||
self.model = str(os.getenv("ANTHROPIC_MODEL", "glm-5.1")).strip() or "glm-5.1"
|
||||
self.timeout = float(os.getenv("API_TIMEOUT_MS", "300000")) / 1000.0
|
||||
|
||||
@property
|
||||
def available(self) -> bool:
|
||||
return bool(self.auth_token)
|
||||
|
||||
def _call(self, system_prompt: str, user_payload: Dict[str, Any]) -> Dict[str, Any]:
|
||||
if not self.available:
|
||||
return {}
|
||||
|
||||
body = {
|
||||
"model": self.model,
|
||||
"max_tokens": 550,
|
||||
"temperature": 0.2,
|
||||
"system": system_prompt,
|
||||
"messages": [
|
||||
{
|
||||
"role": "user",
|
||||
"content": json.dumps(user_payload, ensure_ascii=True),
|
||||
}
|
||||
],
|
||||
}
|
||||
|
||||
request = Request(
|
||||
self.base_url,
|
||||
data=json.dumps(body).encode("utf-8"),
|
||||
headers={
|
||||
"Content-Type": "application/json",
|
||||
"x-api-key": self.auth_token,
|
||||
"anthropic-version": "2023-06-01",
|
||||
},
|
||||
method="POST",
|
||||
)
|
||||
|
||||
try:
|
||||
with urlopen(request, timeout=self.timeout) as response:
|
||||
payload = json.loads(response.read().decode("utf-8", errors="replace"))
|
||||
except (HTTPError, URLError, TimeoutError) as error:
|
||||
logger.warning("Judge API request failed: %s", error)
|
||||
return {}
|
||||
except Exception as error:
|
||||
logger.warning("Judge API unexpected error: %s", error)
|
||||
return {}
|
||||
|
||||
text_chunks: List[str] = []
|
||||
for item in payload.get("content", []) or []:
|
||||
if isinstance(item, dict) and item.get("type") == "text":
|
||||
text_chunks.append(str(item.get("text", "")))
|
||||
return _extract_json_object("\n".join(text_chunks))
|
||||
|
||||
def judge_palette_candidates(
|
||||
self,
|
||||
genre: str,
|
||||
style: str,
|
||||
bpm: float,
|
||||
key: str,
|
||||
candidates: List[Dict[str, Any]],
|
||||
trend_context: Optional[Dict[str, Any]] = None,
|
||||
) -> Dict[str, Any]:
|
||||
if not candidates:
|
||||
return {
|
||||
"available": False,
|
||||
"selected_candidate_id": "",
|
||||
"judges": [],
|
||||
"aggregate": {},
|
||||
"directives": {},
|
||||
}
|
||||
|
||||
if not self.available:
|
||||
top = candidates[0]
|
||||
return {
|
||||
"available": False,
|
||||
"selected_candidate_id": top.get("id", ""),
|
||||
"judges": [],
|
||||
"aggregate": {
|
||||
"selected_candidate_id": top.get("id", ""),
|
||||
"score": float(top.get("score", 0.0)),
|
||||
"mode": "heuristic_fallback",
|
||||
},
|
||||
"directives": {
|
||||
"rhythm_density": "focused",
|
||||
"bass_motion": "syncopated",
|
||||
"arrangement_emphasis": ["intro", "build", "drop", "break", "drop", "outro"],
|
||||
"vocal_strategy": "supportive",
|
||||
},
|
||||
}
|
||||
|
||||
shortlist = candidates[:4]
|
||||
common_payload = {
|
||||
"request": {
|
||||
"genre": genre,
|
||||
"style": style,
|
||||
"bpm": bpm,
|
||||
"key": key,
|
||||
},
|
||||
"trend_context": trend_context or {},
|
||||
"candidates": shortlist,
|
||||
"response_contract": {
|
||||
"selected_candidate_id": "string",
|
||||
"score": "number_0_to_10",
|
||||
"strengths": ["string"],
|
||||
"weaknesses": ["string"],
|
||||
"directives": {
|
||||
"rhythm_density": "string",
|
||||
"bass_motion": "string",
|
||||
"vocal_strategy": "string",
|
||||
"arrangement_emphasis": ["string"],
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
judge_specs = [
|
||||
(
|
||||
"rhythm",
|
||||
(
|
||||
"You are a reggaeton rhythm judge. Choose the palette candidate that will "
|
||||
"produce the strongest dembow pocket, drum/bass chemistry and rhythmic coherence. "
|
||||
"Respond as JSON only."
|
||||
),
|
||||
),
|
||||
(
|
||||
"harmony",
|
||||
(
|
||||
"You are a reggaeton harmony and hook judge. Choose the palette candidate that will "
|
||||
"produce the best tonal fit, melodic identity and vocal/music compatibility. "
|
||||
"Respond as JSON only."
|
||||
),
|
||||
),
|
||||
(
|
||||
"arrangement",
|
||||
(
|
||||
"You are a reggaeton arrangement judge. Choose the palette candidate that best supports "
|
||||
"professional intro/build/drop/break/drop/outro pacing and section contrast. "
|
||||
"Respond as JSON only."
|
||||
),
|
||||
),
|
||||
]
|
||||
|
||||
judge_results: List[Dict[str, Any]] = []
|
||||
with ThreadPoolExecutor(max_workers=min(3, len(judge_specs))) as executor:
|
||||
future_map = {
|
||||
executor.submit(self._call, prompt, {**common_payload, "judge_role": judge_name}): judge_name
|
||||
for judge_name, prompt in judge_specs
|
||||
}
|
||||
for future in as_completed(future_map):
|
||||
judge_name = future_map[future]
|
||||
try:
|
||||
result = future.result() or {}
|
||||
except Exception as error:
|
||||
logger.warning("Judge future failed (%s): %s", judge_name, error)
|
||||
result = {}
|
||||
if result:
|
||||
result["judge"] = judge_name
|
||||
judge_results.append(result)
|
||||
|
||||
if not judge_results:
|
||||
top = shortlist[0]
|
||||
return {
|
||||
"available": False,
|
||||
"selected_candidate_id": top.get("id", ""),
|
||||
"judges": [],
|
||||
"aggregate": {
|
||||
"selected_candidate_id": top.get("id", ""),
|
||||
"score": float(top.get("score", 0.0)),
|
||||
"mode": "api_failed_heuristic_fallback",
|
||||
},
|
||||
"directives": {
|
||||
"rhythm_density": "focused",
|
||||
"bass_motion": "syncopated",
|
||||
"arrangement_emphasis": ["intro", "build", "drop", "break", "drop", "outro"],
|
||||
"vocal_strategy": "supportive",
|
||||
},
|
||||
}
|
||||
|
||||
vote_counter: Dict[str, float] = {}
|
||||
directives: Dict[str, Any] = {}
|
||||
strengths: List[str] = []
|
||||
weaknesses: List[str] = []
|
||||
|
||||
for result in judge_results:
|
||||
candidate_id = str(result.get("selected_candidate_id", "")).strip()
|
||||
score = float(result.get("score", 0.0) or 0.0)
|
||||
if candidate_id:
|
||||
vote_counter[candidate_id] = vote_counter.get(candidate_id, 0.0) + max(0.1, score)
|
||||
strengths.extend(str(item) for item in result.get("strengths", []) or [])
|
||||
weaknesses.extend(str(item) for item in result.get("weaknesses", []) or [])
|
||||
for key_name, value in dict(result.get("directives", {}) or {}).items():
|
||||
if key_name not in directives and value not in (None, "", []):
|
||||
directives[key_name] = value
|
||||
|
||||
selected_candidate_id = max(vote_counter.items(), key=lambda item: item[1])[0] if vote_counter else shortlist[0].get("id", "")
|
||||
aggregate_score = round(sum(float(result.get("score", 0.0) or 0.0) for result in judge_results) / len(judge_results), 2)
|
||||
|
||||
return {
|
||||
"available": True,
|
||||
"model": self.model,
|
||||
"selected_candidate_id": selected_candidate_id,
|
||||
"judges": judge_results,
|
||||
"aggregate": {
|
||||
"selected_candidate_id": selected_candidate_id,
|
||||
"score": aggregate_score,
|
||||
"strengths": list(dict.fromkeys(strengths))[:10],
|
||||
"weaknesses": list(dict.fromkeys(weaknesses))[:10],
|
||||
},
|
||||
"directives": directives,
|
||||
}
|
||||
Reference in New Issue
Block a user