Update trap_transformer.py

trap_transformer.py

@@ -1,180 +1,127 @@
 #!/usr/bin/env python3
-"""
-Trap Style Transformer - Convert MIDI to Trap Beat
-Adds 808s, hi-hats, and trap patterns to existing MIDI
-"""
+"""Trap Style MIDI Transformer"""
 
 import pretty_midi as pm
 import numpy as np
-from pathlib import Path
 import random
+from pathlib import Path
 
 class TrapTransformer:
     def __init__(self, bpm=140):
         self.bpm = bpm
         self.beat_duration = 60.0 / bpm
-        
+
     def extract_bass_notes(self, midi_data):
-        """Extract low notes (bass/808 candidate)"""
+        """Pull low notes that can become 808s"""
         bass_notes = []
         for track in midi_data.instruments:
+            if track.is_drum:
+                continue
             for note in track.notes:
-                # Notes below C3 (~130Hz) are bass candidates
-                if note.pitch < 48:  # C3
+                if note.pitch < 48:  # Below C3
                     bass_notes.append(note)
         return bass_notes
-    
-    def create_808_bass_pattern(self, original_bass_notes, duration_seconds):
-        """Enhance bass with longer 808 sustain"""
-        enhanced_bass = []
-        
-        for note in original_bass_notes:
-            # Make bass longer (808 characteristic)
+
+    def create_808_bass(self, bass_notes, duration_seconds):
+        """Longer sustain + louder = 808 feel"""
+        enhanced = []
+        for note in bass_notes:
             new_note = pm.Note(
-                velocity=min(note.velocity + 20, 127),  # Louder
+                velocity=min(note.velocity + 20, 127),
                 pitch=note.pitch,
                 start=note.start,
-                end=min(note.end + 0.3, duration_seconds)  # Extend by 300ms
+                end=min(note.end + 0.3, duration_seconds),
             )
-            enhanced_bass.append(new_note)
-        
-        return enhanced_bass
-    
-    def add_hi_hat_patterns(self, duration_seconds):
-        """Add trap hi-hat rolls (triplets/fast hats)"""
-        hat_track = pm.Instrument(program=0, is_drum=True)
-        
-        # Hi-hat pattern: fast 1/32 notes with occasional rolls
-        hat_start = 0.0
-        while hat_start < duration_seconds:
-            # Regular 1/8 or 1/16 hi-hats
-            hat_duration = self.beat_duration / 4  # 1/16 notes
-            
-            # Random chance for roll (1/32 or 1/64)
-            if random.random() < 0.3:  # 30% chance of roll
-                roll_count = random.choice([4, 8, 16])  # Number of rolled hats
-                for i in range(roll_count):
-                    hat = pm.Note(
-                        velocity=random.randint(80, 120),
-                        pitch=42,  # Closed hi-hat
-                        start=hat_start + (i * hat_duration / roll_count),
-                        end=hat_start + ((i + 1) * hat_duration / roll_count)
+            enhanced.append(new_note)
+        return enhanced
+
+    def add_hi_hats(self, duration_seconds):
+        """Fast hi-hat rolls (trap signature)"""
+        hat_track = pm.Instrument(program=0, is_drum=True, name="HiHats")
+        t = 0.0
+        while t < duration_seconds:
+            step = self.beat_duration / 4  # 1/16 notes
+            if random.random() < 0.3:  # 30% chance → roll
+                rolls = random.choice([4, 8])
+                for i in range(rolls):
+                    hat_track.notes.append(
+                        pm.Note(
+                            velocity=random.randint(80, 120),
+                            pitch=42,
+                            start=t + (i * step / rolls),
+                            end=t + ((i + 1) * step / rolls),
+                        )
                     )
-                    hat_track.notes.append(hat)
-                hat_start += hat_duration
             else:
-                hat = pm.Note(
-                    velocity=random.randint(90, 115),
-                    pitch=42,  # Closed hi-hat
-                    start=hat_start,
-                    end=hat_start + hat_duration * 0.5
+                hat_track.notes.append(
+                    pm.Note(
+                        velocity=random.randint(90, 115),
+                        pitch=42,
+                        start=t,
+                        end=t + step * 0.5,
+                    )
                 )
-                hat_track.notes.append(hat)
-                hat_start += hat_duration
-        
+            t += step
         return hat_track
-    
+
     def add_trap_drums(self, duration_seconds):
-        """Add 808 kick and snare/clap pattern"""
-        drum_track = pm.Instrument(program=0, is_drum=True)
-        
-        # Kick pattern: every 1st and 3rd beat (typical trap half-time)
-        kick_times = [beat * self.beat_duration * 2 for beat in range(int(duration_seconds / (self.beat_duration * 2)))]
-        
-        for kick_time in kick_times:
-            if kick_time < duration_seconds:
-                kick = pm.Note(
-                    velocity=120,  # Punchy kick
-                    pitch=36,  # Kick drum
-                    start=kick_time,
-                    end=kick_time + 0.1
-                )
-                drum_track.notes.append(kick)
-        
-        # Snare/clap on beats 2 and 4
-        snare_times = [(beat + 1) * self.beat_duration * 2 for beat in range(int(duration_seconds / (self.beat_duration * 2)))]
-        
-        for snare_time in snare_times:
-            if snare_time < duration_seconds:
-                snare = pm.Note(
-                    velocity=110,
-                    pitch=38,  # Snare
-                    start=snare_time,
-                    end=snare_time + 0.08
-                )
-                drum_track.notes.append(snare)
-        
+        """Half-time kicks + snares"""
+        drum_track = pm.Instrument(program=0, is_drum=True, name="TrapDrums")
+        bar = self.beat_duration * 2  # Half-time bar
+        num_bars = int(duration_seconds / bar)
+
+        for b in range(num_bars):
+            kick_t = b * bar
+            snare_t = b * bar + self.beat_duration  # Snare on beat 3 (half-time)
+
+            drum_track.notes.append(
+                pm.Note(velocity=120, pitch=36, start=kick_t, end=kick_t + 0.1)
+            )
+            drum_track.notes.append(
+                pm.Note(velocity=110, pitch=38, start=snare_t, end=snare_t + 0.08)
+            )
         return drum_track
-    
-    def apply_sidechain_compression(self, midi_data, kick_times):
-        """Simulate sidechain pumping effect"""
-        # Lower melody volume slightly before each kick
+
+    def apply_sidechain(self, midi_data, kick_times):
+        """Simulate sidechain pump — duck melody before kicks"""
         for instrument in midi_data.instruments:
-            if not instrument.is_drum:
-                for note in instrument.notes:
-                    # Find kicks that overlap with this note
-                    for kick_time in kick_times:
-                        if note.start <= kick_time <= note.end:
-                            # Reduce velocity slightly
-                            note.velocity = max(0, note.velocity - 10)
+            if instrument.is_drum:
+                continue
+            for note in instrument.notes:
+                for kt in kick_times:
+                    if note.start <= kt <= note.end:
+                        note.velocity = max(1, note.velocity - 10)
         return midi_data
-    
+
     def transform_to_trap(self, input_midi_path, output_midi_path=None):
-        """Main function: Transform any MIDI to Trap style"""
+        """Main: transform any MIDI → Trap"""
         midi_data = pm.PrettyMIDI(str(input_midi_path))
-        
-        # Calculate duration
         duration = midi_data.get_end_time()
-        
-        # Extract and enhance bass
+
+        # Enhance existing bass
         bass_notes = self.extract_bass_notes(midi_data)
-        enhanced_bass = self.create_808_bass_pattern(bass_notes, duration)
-        
-        # Create new trap tracks
-        hat_track = self.add_hi_hat_patterns(duration)
+        enhanced_bass = self.create_808_bass(bass_notes, duration)
+
+        # Add new drum + hat tracks
+        hat_track = self.add_hi_hats(duration)
         drum_track = self.add_trap_drums(duration)
-        
-        # Replace bass track with enhanced version
-        # (or add as new track depending on preference)
-        
-        # Apply sidechain compression
+
+        # Sidechain
         kick_times = [n.start for n in drum_track.notes if n.pitch == 36]
-        midi_data = self.apply_sidechain_compression(midi_data, kick_times)
-        
-        # Add trap tracks to the MIDI
+        midi_data = self.apply_sidechain(midi_data, kick_times)
+
+        # Append trap layers
         midi_data.instruments.append(hat_track)
         midi_data.instruments.append(drum_track)
-        
-        # Update tempo to trap range
-        midi_data.tempos = [self.bpm]
-        
-        # Save if output path provided
+
+        # Set tempo
+        try:
+            for tempo_change in midi_data._tempo_changes:
+                tempo_change.tempo = self.bpm
+        except Exception:
+            pass
+
         if output_midi_path:
             midi_data.write(str(output_midi_path))
-        
-        return midi_data
 
-def transcribe_and_convert(audio_path, model_size="medium", trap_output_path=None):
-    """Full pipeline: Transcribe audio → Transform to Trap → Save MIDI"""
-    from muscriptor import TranscriptionModel
-    
-    # Step 1: Transcribe with MuScriptor
-    print("🎹 Transcribing audio...")
-    model = TranscriptionModel.load_model(model_size)
-    
-    # Get MIDI bytes from original transcription
-    midi_bytes = model.transcribe_to_midi(str(audio_path))
-    
-    # Save temporary MIDI file
-    temp_midi = Path(tempfile.mktemp(suffix=".mid"))
-    temp_midi.write_bytes(midi_bytes)
-    
-    # Step 2: Transform to Trap
-    print("🔥 Converting to Trap style...")
-    transformer = TrapTransformer(bpm=140)
-    trap_midi = transformer.transform_to_trap(temp_midi, trap_output_path)
-    
-    # Cleanup
-    temp_midi.unlink()
-    
-    return trap_midi
+        return midi_data