Update app.py

app.py

@@ -1,111 +1,61 @@
-from sklearn.metrics.pairwise import cosine_similarity
-import pandas as pd
-import numpy as np
-from vectorization import spotify_data
-import json
+from Recomendation import recommend_song_interface
 import gradio as gr
-from gradio.components import Textbox
-from ast import literal_eval
-spotify_data_processed = pd.read_csv('dataset_modificado.csv')
+import requests
 
-def convert_string_to_array(str_vector):
-    # Si str_vector ya es un array de NumPy, devolverlo directamente
-    if isinstance(str_vector, np.ndarray):
-        return str_vector
 
-    try:
-        cleaned_str = str_vector.replace('[', '').replace(']', '').replace('\n', ' ').replace('\r', '').strip()
-        vector_elements = [float(item) for item in cleaned_str.split()]
-        return np.array(vector_elements)
-    except ValueError as e:
-        print("Error:", e)
-        return np.zeros((100,))
 
+def search_youtube(song, artist, api_key):
+    query = f"{song} by {artist}"
+    search_url = "https://www.googleapis.com/youtube/v3/search"
+    params = {
+        'part': 'snippet',
+        'q': query,
+        'type': 'video',
+        'maxResults': 1,
+        'key': api_key
+    }
 
-spotify_data_processed['song_vector'] = spotify_data_processed['song_vector'].apply(convert_string_to_array)
+    response = requests.get(search_url, params=params)
+    response_json = response.json()
 
-
-# Aplicar la función a las primeras filas para ver los resultados
-sample_data = spotify_data_processed['song_vector'].head()
-converted_vectors = sample_data.apply(convert_string_to_array)
-print(converted_vectors)
-
-
-
-def recommend_song(song_name, artist_name, spotify_data_processed, top_n=4):
-    # Filtrar para encontrar la canción específica
-    specific_song = spotify_data_processed[(spotify_data_processed['song'] == song_name)
-                                            & (spotify_data_processed['artist'] == artist_name)]
-
-    # Verificar si la canción existe en el dataset
-    if specific_song.empty:
-        return pd.DataFrame({"Error": ["Canción no encontrada en la base de datos."]})
-
-
-    # Obtener el vector de la canción específica
-    song_vec = specific_song['song_vector'].iloc[0]
-
-    # Asegurarte de que song_vec sea un array de NumPy
-    if isinstance(song_vec, str):
-        song_vec = convert_string_to_array(song_vec)
-
-    all_song_vectors = np.array(spotify_data_processed['song_vector'].tolist())
-
-    # Calcular similitudes
-    similarities = cosine_similarity([song_vec], all_song_vectors)[0]
-
-    # Obtener los índices de las canciones más similares
-    top_indices = np.argsort(similarities)[::-1][1:top_n+1]
-
-    # Devolver los nombres y artistas de las canciones más similares
-    recommended_songs = spotify_data_processed.iloc[top_indices][['song', 'artist']]
-    return recommended_songs
-
-
-
-
-
-
-def recommend_song_interface(song_name, artist_name):
-    recommendations_df = recommend_song(song_name, artist_name, spotify_data_processed)
-    
-    if isinstance(recommendations_df, pd.DataFrame) and not recommendations_df.empty and {'song', 'artist'}.issubset(recommendations_df.columns):
-        recommendations_list = recommendations_df[['song', 'artist']].values.tolist()
-        formatted_recommendations = ["{} by {}".format(song, artist) for song, artist in recommendations_list]
-        while len(formatted_recommendations) < 4:
-            formatted_recommendations.append("")
-        return formatted_recommendations[:4]
+    if 'items' in response_json and response_json['items']:
+        video_id = response_json['items'][0]['id']['videoId']
+        youtube_link = f"https://www.youtube.com/watch?v={video_id}"
+        return youtube_link
     else:
-        # Si no se encuentran recomendaciones, seleccionar una canción aleatoria del dataset
-        random_song = spotify_data_processed.sample()
-        random_song_name = random_song['song'].iloc[0]
-        random_artist_name = random_song['artist'].iloc[0]
-        
-        # Obtener recomendaciones para la canción aleatoria
-        random_recommendations_df = recommend_song(random_song_name, random_artist_name, spotify_data_processed)
-        random_recommendations_list = random_recommendations_df[['song', 'artist']].values.tolist()
-        formatted_random_recommendations = ["{} by {}".format(song, artist) for song, artist in random_recommendations_list]
-        
-        # Rellenar con cadenas vacías si hay menos de 4 recomendaciones
-        while len(formatted_random_recommendations) < 4:
-            formatted_random_recommendations.append("")
-        return formatted_random_recommendations[:4]
-    recommendations = recommend_song_interface("song_name", "artist_name")
-
-
-# Crear la interfaz con Gradio
+        return "No se encontraron resultados."
+
+def add_youtube_links(recommendations, api_key):
+    recommendations_with_links = []
+    for recommendation in recommendations:
+        if recommendation:  # Si la recomendación no es una cadena vacía
+            song, artist = recommendation.split(" by ")
+            youtube_link = search_youtube(song, artist, api_key)
+            recommendations_with_links.append(f"{recommendation} - YouTube Link: {youtube_link}")
+        else:
+            recommendations_with_links.append("")
+
+    return recommendations_with_links
+
+def recommend_with_youtube_links(song_name, artist_name):
+    api_key = "AIzaSyAnFiRh8g13HW_wLhUW7wZwRE2SsPo0aJs"
+    recommendations = recommend_song_interface(song_name, artist_name)
+    recommendations_with_links = add_youtube_links(recommendations, api_key)
+    return recommendations_with_links
+
+# Configuración de la interfaz Gradio
 iface = gr.Interface(
-    fn=recommend_song_interface,
+    fn=recommend_with_youtube_links,
     inputs=[
         gr.Textbox(placeholder="Ingrese el título de la canción", label="Título de la Canción"),
         gr.Textbox(placeholder="Ingrese el nombre del artista", label="Nombre del Artista")
     ],
-    outputs=[gr.Text(label="Recomendación 1"),
-             gr.Text(label="Recomendación 2"),
-             gr.Text(label="Recomendación 3"),
-             gr.Text(label="Recomendación 4")],
-    title="Recomendador de Canciones",
-    description="Ingrese el título de una canción y el nombre del artista para obtener recomendaciones.",
+    outputs=[gr.HTML(label="Recomendación 1"),
+             gr.HTML(label="Recomendación 2"),
+             gr.HTML(label="Recomendación 3"),
+             gr.HTML(label="Recomendación 4")],
+    title="Recomendador de Canciones con Enlaces de YouTube",
+    description="Ingrese el título de una canción y el nombre del artista.",
     theme="dark",  # Comenta o elimina si el tema oscuro no está disponible
     css="""
         body {font-family: Arial, sans-serif;}
@@ -115,4 +65,3 @@ iface = gr.Interface(
 )
 
 iface.launch()
-