Convert from file

app.py

@@ -7,7 +7,7 @@ from datasets import load_dataset
 import json
 import os
 
-from src.convert import get_embeddings_from_chord_sequences
+from src.convert import get_embeddings_from_chord_sequences, get_embedding_from_filepaths
 from src.analysis import EmbeddingsAnalysis
 
 # Configuration
@@ -57,62 +57,70 @@ def neighbours_to_dict(neighbours_list):
         result.append(group_result)
     return result
 
+def _perform_analysis(embeddings, sequence_lengths):
+    """Private function to perform analysis on embeddings and format results"""
+    # Get scores
+    scores = ea.get_scores(embeddings, sequence_lengths)
+    
+    # Get neighbours
+    neighbours = ea.get_neighbours(embeddings, limit=10)
+    
+    # Format results
+    score = scores[0]
+    scores_text = f"**Originality Score:** {score:.4f}"
+    
+    # Format neighbours
+    neighbours_text = "**Similar Songs:**\n"
+    if neighbours and len(neighbours) > 0 and len(neighbours[0]) > 0:
+        for i, neighbor in enumerate(neighbours[0][:5], 1):  # Show top 5
+            title = neighbor.metadata.get('title', 'Unknown')
+            artist = neighbor.metadata.get('artist', 'Unknown')
+            distance = neighbor.distance
+            neighbours_text += f"{i}. {title} by {artist} (distance: {distance:.3f})\n"
+    else:
+        neighbours_text += "No similar songs found."
+        
+    return scores_text, neighbours_text
+
 def analyze_chord_sequence(chord_text):
     """Analyze a chord sequence from text input"""
     try:
         chords = parse_chord_input(chord_text)
         
         if not chords:
-            return "Please enter some chords!", "", ""
+            return "Please enter some chords!", ""
         
         # Get embeddings
         embeddings = get_embeddings_from_chord_sequences([chords])
         
-        # Get scores
-        scores = ea.get_scores(embeddings, [len(chords)])
-        
-        # Get neighbours
-        neighbours = ea.get_neighbours(embeddings, limit=10)
-        
-        # Format results
-        # Simple originality score display
-        score = scores[0]
-        scores_text = f"**Originality Score:** {score:.4f}"
-        
-        # Format neighbours
-        neighbours_text = "**Similar Songs:**\n"
-        if neighbours and len(neighbours) > 0 and len(neighbours[0]) > 0:
-            for i, neighbor in enumerate(neighbours[0][:5], 1):  # Show top 5
-                title = neighbor.metadata.get('title', 'Unknown')
-                artist = neighbor.metadata.get('artist', 'Unknown')
-                distance = neighbor.distance
-                neighbours_text += f"{i}. {title} by {artist} (distance: {distance:.3f})\n"
-        else:
-            neighbours_text += "No similar songs found."
-            
-        return scores_text, neighbours_text
+        # Perform analysis using shared logic
+        return _perform_analysis(embeddings, [len(chords)])
         
     except Exception as e:
         return f"Error: {str(e)}", ""
 
 def analyze_music_file(audio_file):
-    """Analyze music file - placeholder for now"""
+    """Analyze music file by extracting chords and computing embeddings"""
     if audio_file is None:
         return "Please upload a music file!", "", ""
     
-    # This is a placeholder - you'll need to implement audio processing
-    # For now, we'll return a message about future implementation
-    return (
-        "**File uploaded:** " + audio_file.name,
-        "Audio analysis feature coming soon! Currently, this would:\n"
-        "1. Extract chords from the audio file\n"
-        "2. Convert them to embeddings\n"
-        "3. Analyze originality and find similar songs",
-        "Please use the 'Text Input' tab for now to analyze chord sequences directly."
-    )
+    try:
+        # Get embeddings from the audio file
+        embeddings, chord_lens = get_embedding_from_filepaths([audio_file])
+        
+        # Perform analysis using shared logic
+        scores_text, neighbours_text = _perform_analysis(embeddings, chord_lens)
+        
+        # Add file info
+        file_info = f"**File analyzed:** {os.path.basename(audio_file)}"
+        
+        return file_info, scores_text, neighbours_text
+        
+    except Exception as e:
+        return f"**Error processing file:** {str(e)}", "", ""
 
 # Create Gradio interface
-with gr.Blocks(title="Harmonic Analysis Tool") as app:
+with gr.Blocks(title="Harmonic Analysis Tool", theme=gr.themes.Soft()) as app:
     gr.Markdown("# 🎵 Harmonic Analysis Tool")
     gr.Markdown("Analyze chord progressions for originality and find similar songs in the database.")
     
@@ -191,6 +199,5 @@ if __name__ == "__main__":
         server_name="0.0.0.0",
         server_port=7860,
         share=False,
-        show_error=True,
-        theme=gr.themes.Soft()
+        show_error=True
     )

src/convert.py

@@ -3,8 +3,12 @@ from gradio_client import Client
 import os
 import json
 
+from chord_extractor.extractors import Chordino
+from chord_extractor import clear_conversion_cache, LabelledChordSequence
+
 _CONSTANT_GAP_SECS = 2 
 _SEQ_EMBED_SPACE = 'ohollo/chord-seq-embed'
+_POST_PROCESS_CHORD_LEN_RATIO = 0.7
 
 
 _client = Client(_SEQ_EMBED_SPACE)
@@ -26,3 +30,28 @@ def get_embeddings_from_chord_sequences(chord_sequences: list[list[str]], consta
         for chord_sequence in chord_sequences
     ]
     return np.array(_call_embedding_service(chords_w_timestamps)['embeddings'])
+
+
+def get_embedding_from_filepaths(file_paths: list[str]) -> tuple[np.ndarray, list[int]]:
+    """
+    Reads chord sequences from a given filepath and converts them into embeddings.
+
+    :param file_paths: List of paths to the audio files. Can be anything supported by chord-extractor - .mid, .wav, .mp3, .ogg
+    :return: 2-d numpy array of embeddings per chord sequence.
+    """
+    chords_w_timestamps = []
+    chord_lengths = []
+    chordino = Chordino() 
+    for file_path in file_paths:
+        if not os.path.isfile(file_path):
+            raise FileNotFoundError(f"File not found: {file_path}")
+        
+        conversion_file_path = chordino.preprocess(file_path)
+
+        chords = chordino.extract(conversion_file_path if conversion_file_path else file_path)
+        chords_w_timestamps.append({
+            'label': [chord.chord for chord in chords],
+            'timestamp': [chord.timestamp for chord in chords]
+        })
+        chord_lengths.append(int(len(chords) * _POST_PROCESS_CHORD_LEN_RATIO))
+    return np.array(_call_embedding_service(chords_w_timestamps)['embeddings']), chord_lengths

src/neighbours.py

@@ -35,7 +35,6 @@ class EmbeddingClosestNeighbours:
         self._close_threshold = close_threshold
 
     def get(self, embeddings: np.ndarray, limit: int = None) -> list[list[Neighbour]]:
-        # lims, D, I = self._index.range_search(embeddings, self._close_threshold)
         all_neighbours = []
         for indices_, distances_ in indices_distances_gen(embeddings, self._close_threshold, self._index):
             lengths_ = self._lengths[indices_]