test

Dockerfile

@@ -42,4 +42,4 @@ RUN apt-get clean
 COPY app.py /app/app.py
 WORKDIR /app
 
-CMD ["python3", "app.py"]
+CMD ["python3", "app.py"]

README.md

@@ -10,6 +10,8 @@ pinned: false
 license: apache-2.0
 short_description: Analyze music scores from PDF files
 app_port: 7860
+tags:
+  - mcp-server-track
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -1,281 +1,37 @@
 import gradio as gr
+import subprocess
 import os
-import shutil
-import tempfile
-import threading
-import http.server
-import socketserver
-from urllib.parse import urljoin
-import time
-
-# Global variable to store the HTTP server
-file_server = None
-server_port = 8000
-
-def start_file_server(directory, port=8000):
-    """Start a simple HTTP server to serve files"""
-    global file_server
-    
-    class Handler(http.server.SimpleHTTPRequestHandler):
-        def __init__(self, *args, **kwargs):
-            super().__init__(*args, directory=directory, **kwargs)
-    
-    try:
-        file_server = socketserver.TCPServer(("", port), Handler)
-        server_thread = threading.Thread(target=file_server.serve_forever, daemon=True)
-        server_thread.start()
-        return f"http://localhost:{port}"
-    except Exception as e:
-        print(f"Error starting file server: {e}")
-        return None
 
 def recognize_music(pdf_file):
-    """Converts a PDF file to a Music score using MCP Audiveris
+    """Converts a PDF file to a Music score
     
     Args:
         pdf_file: the file with the PDF file
         
     Returns:
-        the result from MCP Audiveris conversion
-    """
-    if pdf_file is None:
-        return "No file uploaded"
-    
-    try:
-        # Get the file path
-        pdf_file_path = pdf_file.name if hasattr(pdf_file, 'name') else str(pdf_file)
-        
-        # Create a temporary directory for serving the file
-        temp_dir = tempfile.mkdtemp()
-        
-        # Copy the file to the temporary directory with a simple name
-        temp_pdf_name = "input.pdf"
-        temp_pdf_path = os.path.join(temp_dir, temp_pdf_name)
-        shutil.copy2(pdf_file_path, temp_pdf_path)
-        
-        # Start a simple HTTP server to serve the file
-        server_url = start_file_server(temp_dir, server_port)
-        if not server_url:
-            return "Error: Could not start file server"
-        
-        # Create the URL for the PDF file
-        pdf_url = f"{server_url}/{temp_pdf_name}"
-        
-        # Wait a moment for the server to be ready
-        time.sleep(0.5)
-        
-        # Now we can use the MCP Audiveris function with the URL
-        # Note: This is where you would call the MCP function
-        # For now, I'll show how it would be called:
-        
-        # Example of how to call MCP Audiveris (uncomment when ready to use):
-        # from mcp_audiveris import convert_and_display
-        # result = convert_and_display(pdf_url)
-        # return result
-        
-        # For now, let's fall back to local processing
-        audiveris = "/opt/audiveris/bin/Audiveris"
-        output_dir = temp_dir
-        pdf_file_name = os.path.basename(pdf_file_path)
-        musicXml_file_name = os.path.splitext(pdf_file_name)[0]+".mxl"
-        output_file = os.path.join(output_dir, musicXml_file_name)
-
-        import subprocess
-        cmd = [
-            audiveris, "-batch", "-export", "-output", output_dir, temp_pdf_path
-        ]
-
-        result = subprocess.run(cmd, capture_output=True, text=True)
-
-        print(f"Done. Music score file saved to {output_file}\n\n{result.stdout}\n{result.stderr}")
-        print(f"PDF was served at: {pdf_url}")
-
-        if os.path.exists(output_file):
-            return output_file
-        else:
-            return f"Error: Output file not created. {result.stderr}"
-            
-    except Exception as e:
-        return f"Error processing file: {str(e)}"
-
-# Alternative function that directly uses MCP Audiveris
-def recognize_music_mcp(pdf_file):
-    """Converts a PDF file using MCP Audiveris directly"""
-    if pdf_file is None:
-        return "No file uploaded"
-    
-    try:
-        # For MCP Audiveris, we need a URL
-        # If you have the file hosted somewhere, use that URL
-        # For local files, you'd need to upload them to a temporary hosting service
-        
-        # This is a placeholder - you would need to implement file hosting
-        # or use a service like temporary file hosting
-        return "MCP Audiveris requires a URL. Please host your PDF file online and provide the URL."
-        
-    except Exception as e:
-        return f"Error: {str(e)}"
-
-def recognize_music_from_url(pdf_url):
-    """Converts a PDF file to a Music score using MCP Audiveris
-    
-    Args:
-        pdf_url: URL to the PDF file (must be http:// or https://)
-        
-    Returns:
-        the result from MCP Audiveris conversion
+        the path were the MusicXML file is generated
     """
-    if not pdf_url:
-        return "Please provide a PDF URL"
-    
-    if not (pdf_url.startswith('http://') or pdf_url.startswith('https://')):
-        return "Error: URL must start with http:// or https://"
-    
-    # For now, this function serves as a placeholder for MCP integration
-    # When this Gradio app is used as an MCP server, this function will be exposed
-    # as an MCP tool that can be called by MCP clients
-    
-    return f"✅ URL validated: {pdf_url}\n\n📋 This function is ready for MCP integration.\n\nWhen called via MCP client, it will:\n1. Receive the PDF URL\n2. Process it with Audiveris\n3. Return the MusicXML result\n\n🔧 To actually process the PDF, call this function through an MCP client that has access to the Audiveris conversion tools."
+    audiveris = "/opt/audiveris/bin/Audiveris"
+    output_dir = "/tmp/output"
+    pdf_file_path = pdf_file.name
+    pdf_file_name = os.path.basename(pdf_file.name)
+    musicXml_file_name = os.path.splitext(pdf_file_name)[0]+".mxl"
+    output_file = output_dir + "/" + musicXml_file_name
 
-def recognize_music_local(pdf_file):
-    """Converts a local PDF file using local Audiveris installation"""
-    if pdf_file is None:
-        return "No file uploaded"
-    
-    # Handle MCP document references
-    if isinstance(pdf_file, str) and pdf_file.startswith('file://'):
-        return f"Invalid file data format, provide a url ('http://...' or 'https://...'). Received: {pdf_file}"
-    
-    try:
-        import subprocess
-        import os
-        import tempfile
-        import shutil
-        
-        # Get the file path
-        pdf_file_path = pdf_file.name if hasattr(pdf_file, 'name') else str(pdf_file)
-        
-        # Create a temporary directory for output
-        temp_dir = tempfile.mkdtemp()
-        
-        # Copy the file to the temporary directory
-        temp_pdf_path = os.path.join(temp_dir, "input.pdf")
-        shutil.copy2(pdf_file_path, temp_pdf_path)
-        
-        # Use local Audiveris
-        audiveris = "/opt/audiveris/bin/Audiveris"
-        output_dir = temp_dir
-        pdf_file_name = os.path.basename(pdf_file_path)
-        musicXml_file_name = os.path.splitext(pdf_file_name)[0]+".mxl"
-        output_file = os.path.join(output_dir, musicXml_file_name)
-
-        cmd = [
-            audiveris, "-batch", "-export", "-output", output_dir, temp_pdf_path
-        ]
-
-        result = subprocess.run(cmd, capture_output=True, text=True)
+    cmd = [
+        audiveris, "-batch", "-export", "-output", output_dir, pdf_file_path
+    ]
 
-        print(f"Done. Music score file saved to {output_file}\n\n{result.stdout}\n{result.stderr}")
-
-        if os.path.exists(output_file):
-            return output_file
-        else:
-            return f"Error: Output file not created. {result.stderr}"
-            
-    except Exception as e:
-        return f"Error processing file: {str(e)}"
-
-def recognize_music_with_file_server(pdf_file):
-    """Converts a local PDF file by serving it via HTTP and using MCP Audiveris"""
-    if pdf_file is None:
-        return "No file uploaded"
-    
-    # Handle MCP document references
-    if isinstance(pdf_file, str) and pdf_file.startswith('file://'):
-        return f"Invalid file data format, provide a url ('http://...' or 'https://...'). Received: {pdf_file}"
-    
-    try:
-        import tempfile
-        import shutil
-        import threading
-        import http.server
-        import socketserver
-        import time
-        import os
-        
-        # Get the file path
-        pdf_file_path = pdf_file.name if hasattr(pdf_file, 'name') else str(pdf_file)
-        
-        # Create a temporary directory for serving the file
-        temp_dir = tempfile.mkdtemp()
-        
-        # Copy the file to the temporary directory with a simple name
-        temp_pdf_name = "input.pdf"
-        temp_pdf_path = os.path.join(temp_dir, temp_pdf_name)
-        shutil.copy2(pdf_file_path, temp_pdf_path)
-        
-        # Start a simple HTTP server to serve the file
-        server_port = 8000
-        
-        class Handler(http.server.SimpleHTTPRequestHandler):
-            def __init__(self, *args, **kwargs):
-                super().__init__(*args, directory=temp_dir, **kwargs)
-        
-        try:
-            file_server = socketserver.TCPServer(("", server_port), Handler)
-            server_thread = threading.Thread(target=file_server.serve_forever, daemon=True)
-            server_thread.start()
-            server_url = f"http://localhost:{server_port}"
-        except Exception as e:
-            return f"Error starting file server: {e}"
-        
-        # Create the URL for the PDF file
-        pdf_url = f"{server_url}/{temp_pdf_name}"
-        
-        # Wait a moment for the server to be ready
-        time.sleep(0.5)
-        
-        # Call the MCP Audiveris function
-        result = mcp_audiveris_convert_and_display(pdf_url)
-        
-        # Stop the server
-        file_server.shutdown()
-        
-        return result
-        
-    except Exception as e:
-        return f"Error processing file: {str(e)}"
+    result = subprocess.run(cmd, capture_output=True, text=True)
 
-# Create three interfaces
-url_interface = gr.Interface(
-    fn=recognize_music_from_url,
-    inputs=gr.Textbox(label="PDF URL (http:// or https://)", placeholder="https://example.com/music-score.pdf"),
-    outputs=gr.Textbox(label="Result"),
-    description="Enter a URL to a PDF music score to process with MCP Audiveris.",
-    title="URL Input (MCP)"
-)
+    print (f"Done. Music score file saved to {output_file}\n\n{result.stdout}\n{result.stderr}")
 
-file_mcp_interface = gr.Interface(
-    fn=recognize_music_with_file_server,
-    inputs=gr.File(file_types=[".pdf"], label="Upload PDF music score"),
-    outputs=gr.Textbox(label="Result"),
-    description="Upload a PDF music score and process it with MCP Audiveris (via temporary file server). Note: MCP tools require URLs, not file uploads.",
-    title="File Upload (MCP)"
-)
+    return output_file
 
-file_local_interface = gr.Interface(
-    fn=recognize_music_local,
+audiveris = gr.Interface(
+    fn=recognize_music,
     inputs=gr.File(file_types=[".pdf"], label="Upload PDF music score"),
     outputs=gr.File(label="Download MusicXML file"),
-    description="Upload a PDF music score and create a MusicXML file using local Audiveris. Note: MCP tools require URLs, not file uploads.",
-    title="File Upload (Local)"
+    description="Upload a PDF music socre and create a MusicXML file from it.",
 )
-
-# Combine all interfaces in a tabbed interface
-demo = gr.TabbedInterface(
-    [url_interface, file_mcp_interface, file_local_interface],
-    ["URL Input (MCP)", "File Upload (MCP)", "File Upload (Local)"]
-)
-
-if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860, share=True, mcp_server=True)
+audiveris.launch(server_name="0.0.0.0", server_port=7860, share=True, mcp_server=True)