Spaces:
Runtime error
Runtime error
| #!/usr/bin/env python3 | |
| """ | |
| Gradio Demo for SongBPM Scraper | |
| A web-based interface to search and display song BPM and musical key information. | |
| Run with: python gradio_app.py | |
| Then open http://localhost:7860 in your browser. | |
| """ | |
| import asyncio | |
| import gradio as gr | |
| from gradio import processing_utils | |
| import os | |
| import pandas as pd | |
| from pathlib import Path | |
| from songbpm_scraper import SongBPMExtractor, SongData | |
| # Global extractor instance | |
| _extractor = None | |
| def get_extractor(): | |
| """Get or create the extractor instance.""" | |
| global _extractor | |
| if _extractor is None: | |
| _extractor = SongBPMExtractor(headless=True) | |
| return _extractor | |
| def search_song(query: str) -> str: | |
| """ | |
| Search for a single song and return formatted results. | |
| Args: | |
| query: Song search query (artist - song title) | |
| Returns: | |
| Formatted results string | |
| """ | |
| if not query or not query.strip(): | |
| return "Please enter a song to search for." | |
| query = query.strip() | |
| extractor = get_extractor() | |
| try: | |
| results = asyncio.run(extractor.extract(query)) | |
| if not results: | |
| return f"No results found for '{query}'.\n\nTips:\n- Try the format: 'artist - song title'\n- Be more specific with the artist name\n- Check for spelling errors" | |
| # Format results | |
| output_lines = [f"Found {len(results)} result(s):\n"] | |
| for i, song in enumerate(results, 1): | |
| output_lines.append(f"{i}. **{song.get('artist', 'Unknown')}** - {song.get('title', 'Unknown')}") | |
| output_lines.append(f" - BPM: {song.get('bpm', 'N/A')}") | |
| output_lines.append(f" - Key: {song.get('key', 'N/A')}") | |
| output_lines.append(f" - Duration: {song.get('duration', 'N/A')}") | |
| output_lines.append(f" - [Source]({song.get('url', '#')})") | |
| output_lines.append("") | |
| return "\n".join(output_lines) | |
| except Exception as e: | |
| return f"Error searching for '{query}':\n{str(e)}" | |
| def search_batch(file_obj) -> str: | |
| """ | |
| Search for multiple songs from a file. | |
| Args: | |
| file_obj: Gradio file object containing song queries | |
| Returns: | |
| Formatted results string | |
| """ | |
| if file_obj is None: | |
| return "Please upload a file with song queries." | |
| try: | |
| # Read the file | |
| if hasattr(file_obj, 'name'): | |
| with open(file_obj.name, 'r', encoding='utf-8') as f: | |
| queries = [line.strip() for line in f if line.strip()] | |
| else: | |
| # Handle Gradio's file object format | |
| processing_utils.decode_base64_to_file(file_obj) | |
| return "File upload processing not yet implemented. Please try again." | |
| if not queries: | |
| return "The file appears to be empty." | |
| extractor = get_extractor() | |
| results = asyncio.run(extractor.extract_batch(queries)) | |
| if not results: | |
| return f"No results found for any of the {len(queries)} songs in the file." | |
| # Format results | |
| output_lines = [f"Found {len(results)} result(s) from {len(queries)} queries:\n"] | |
| for i, song in enumerate(results, 1): | |
| output_lines.append(f"{i}. **{song.get('artist', 'Unknown')}** - {song.get('title', 'Unknown')}") | |
| output_lines.append(f" BPM: {song.get('bpm', 'N/A')} | Key: {song.get('key', 'N/A')} | Duration: {song.get('duration', 'N/A')}") | |
| output_lines.append("") | |
| output_lines.append(f"---") | |
| output_lines.append(f"Processed {len(queries)} queries, found {len(results)} results.") | |
| return "\n".join(output_lines) | |
| except Exception as e: | |
| return f"Error processing file: {str(e)}" | |
| def search_and_export(query: str, export_format: str) -> tuple: | |
| """ | |
| Search for songs and optionally export results. | |
| Args: | |
| query: Song search query | |
| export_format: Export format ('csv', 'json', or 'none') | |
| Returns: | |
| Tuple of (results_text, file_path) | |
| """ | |
| if not query or not query.strip(): | |
| return ("Please enter a song to search for.", None) | |
| query = query.strip() | |
| extractor = get_extractor() | |
| try: | |
| results = asyncio.run(extractor.extract(query)) | |
| if not results: | |
| return (f"No results found for '{query}'.", None) | |
| # Format results for display | |
| output_lines = [f"Found {len(results)} result(s):\n"] | |
| for i, song in enumerate(results, 1): | |
| output_lines.append(f"{i}. **{song.get('artist', 'Unknown')}** - {song.get('title', 'Unknown')}") | |
| output_lines.append(f" BPM: {song.get('bpm', 'N/A')} | Key: {song.get('key', 'N/A')} | Duration: {song.get('duration', 'N/A')}") | |
| results_text = "\n".join(output_lines) | |
| # Export if requested | |
| file_path = None | |
| if export_format != 'none' and results: | |
| filename = f"songbpm_results" | |
| if export_format == 'csv': | |
| file_path = f"{filename}.csv" | |
| extractor.export_to_csv(results, file_path) | |
| elif export_format == 'json': | |
| file_path = f"{filename}.json" | |
| extractor.export_to_json(results, file_path) | |
| return (results_text, file_path) | |
| except Exception as e: | |
| return (f"Error: {str(e)}", None) | |
| def clear_results() -> tuple: | |
| """Clear all inputs and outputs.""" | |
| return "", "", "none", None | |
| # Create the Gradio interface | |
| def create_demo(): | |
| """Create and configure the Gradio demo.""" | |
| with gr.Blocks(title="SongBPM Scraper") as demo: | |
| gr.Markdown( | |
| """ | |
| # SongBPM Scraper | |
| Search for songs and get their BPM (tempo) and musical key information. | |
| --- | |
| **Data provided by:** [songbpm.com](https://songbpm.com) | |
| *Note: Please be patient between searches to respect the website's resources.* | |
| """ | |
| ) | |
| with gr.Tab("Single Search"): | |
| gr.Markdown("### Search for a Single Song") | |
| with gr.Row(): | |
| with gr.Column(scale=3): | |
| query_input = gr.Textbox( | |
| label="Song Query", | |
| placeholder="e.g., queen - under pressure", | |
| ) | |
| with gr.Column(scale=1): | |
| search_btn = gr.Button("Search", variant="primary") | |
| export_radio = gr.Radio( | |
| choices=["none", "csv", "json"], | |
| label="Export Results", | |
| value="none" | |
| ) | |
| result_output = gr.Markdown(label="Results") | |
| file_output = gr.File(label="Download", visible=False) | |
| search_btn.click( | |
| fn=search_and_export, | |
| inputs=[query_input, export_radio], | |
| outputs=[result_output, file_output] | |
| ) | |
| query_input.submit( | |
| fn=search_and_export, | |
| inputs=[query_input, export_radio], | |
| outputs=[result_output, file_output] | |
| ) | |
| with gr.Tab("Batch Search"): | |
| gr.Markdown("### Search for Multiple Songs") | |
| file_input = gr.File( | |
| label="Upload File", | |
| file_types=[".txt", ".csv"] | |
| ) | |
| batch_search_btn = gr.Button("Search All Songs", variant="primary") | |
| batch_result_output = gr.Markdown(label="Results") | |
| batch_search_btn.click( | |
| fn=search_batch, | |
| inputs=file_input, | |
| outputs=batch_result_output | |
| ) | |
| with gr.Tab("Help"): | |
| gr.Markdown( | |
| """ | |
| ## How to Use | |
| ### Single Search | |
| 1. Enter a song query in the text box | |
| 2. Use the format: `artist - song title` | |
| 3. Click "Search" or press Enter | |
| 4. View results below | |
| ### Batch Search | |
| 1. Create a text file with one query per line | |
| 2. Upload the file | |
| 3. Click "Search All Songs" | |
| ### Examples | |
| ``` | |
| queen - under pressure | |
| daft punk - one more time | |
| metallica - enter sandman | |
| taylor swift - shake it off | |
| ``` | |
| ## Tips | |
| - Use the artist name followed by a dash and the song title | |
| - Be specific with artist names for better results | |
| - Check spelling if you don't get results | |
| - Results include BPM, musical key, and duration | |
| ## Export Options | |
| - **CSV**: Download as spreadsheet-compatible file | |
| - **JSON**: Download as structured data file | |
| - **None**: Just view results in the browser | |
| """ | |
| ) | |
| gr.Markdown( | |
| """ | |
| --- | |
| *Built with Python, Playwright, and Gradio* | |
| **Disclaimer**: This tool is for educational purposes only. Please respect songbpm.com's terms of service. | |
| """ | |
| ) | |
| return demo | |
| def main(): | |
| """Main entry point for the Gradio app.""" | |
| import argparse | |
| parser = argparse.ArgumentParser(description="Run the SongBPM Scraper Gradio Demo") | |
| parser.add_argument( | |
| "--host", | |
| type=str, | |
| default="127.0.0.1", | |
| help="Host to bind to (default: 127.0.0.1)" | |
| ) | |
| parser.add_argument( | |
| "--port", | |
| type=int, | |
| default=7860, | |
| help="Port to bind to (default: 7860)" | |
| ) | |
| parser.add_argument( | |
| "--share", | |
| action="store_true", | |
| help="Create a public share link" | |
| ) | |
| parser.add_argument( | |
| "--debug", | |
| action="store_true", | |
| help="Enable debug mode" | |
| ) | |
| args = parser.parse_args() | |
| print(f""" | |
| ╔════════════════════════════════════════════════════════════╗ | |
| ║ SongBPM Scraper - Gradio Demo ║ | |
| ╠════════════════════════════════════════════════════════════╣ | |
| ║ ║ | |
| ║ Starting server... ║ | |
| ║ ║ | |
| ║ Local URL: http://{args.host}:{args.port} ║ | |
| ║ ║ | |
| ║ Press Ctrl+C to stop the server ║ | |
| ║ ║ | |
| ╚════════════════════════════════════════════════════════════╝ | |
| """) | |
| demo = create_demo() | |
| demo.launch( | |
| server_name=args.host, | |
| server_port=args.port, | |
| share=args.share, | |
| debug=args.debug, | |
| theme="NeoPy/Soft", | |
| show_error=True | |
| ) | |
| if __name__ == "__main__": | |
| main() | |