Update app.py

app.py

@@ -5,103 +5,71 @@ from scipy.io import wavfile
 from voice_processing import parallel_tts, get_model_names
 import os
 import logging
-from rvc_service import RVCService  # Our new service
-import asyncio
-from voice_processing import parallel_tts, get_model_names
-import sys
-from datetime import datetime  # Add this import
-import traceback
-import json
-
-
-# Set up enhanced logging
-logging.basicConfig(
-    level=logging.DEBUG,
-    format='%(asctime)s | %(levelname)s | %(name)s | %(message)s',
-    handlers=[
-        logging.FileHandler('rvc_server.log'),
-        logging.StreamHandler(sys.stdout)
-    ]
-)
-logger = logging.getLogger('rvc_server')
 
-# Initialize RVC Service
-rvc_service = RVCService()
+# Set up logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
 
-def setup_request_logging():
-    """Creates a unique logger for request handling"""
-    request_id = datetime.now().strftime('%Y%m%d_%H%M%S_%f')
-    logger = logging.getLogger(f'request_{request_id}')
-    return logger, request_id
-
-def convert_tts(model_name, audio_file, slang_rate):
-    """Voice conversion endpoint"""
-    req_logger, request_id = setup_request_logging()
-    
+async def convert_tts(model_name, audio_file, slang_rate):
     try:
-        req_logger.info(f"New request received - ID: {request_id}")
-        req_logger.info(f"Parameters: model={model_name}, slang_rate={slang_rate}")
+        logger.debug(f"Received request - model: {model_name}, audio: {type(audio_file)}, slang: {slang_rate}")
         
         if audio_file is None:
-            req_logger.error("No audio file provided")
+            logger.error("No audio file provided")
             return {"error": "No audio file uploaded."}, None
 
-        try:
-            req_logger.info(f"Processing audio file: {audio_file}")
-            sr, audio = wavfile.read(audio_file)
-            req_logger.info(f"Audio loaded: sr={sr}Hz, shape={audio.shape}")
-
-            # Create task for parallel processing
-            task = (model_name, None, None, slang_rate, True, audio_file)
-            
-            req_logger.info("Running parallel processing")
-            result = parallel_tts([task])
+        # Log the audio file details
+        if hasattr(audio_file, 'name'):
+            logger.debug(f"Audio file name: {audio_file.name}")
+        logger.debug(f"Audio file type: {type(audio_file)}")
+        
+        # Create task for parallel processing
+        task = (model_name, None, None, slang_rate, True, audio_file)
+        
+        # Process the audio
+        logger.debug("Starting audio processing")
+        result = parallel_tts([task])
+        logger.debug(f"Processing result: {type(result)}")
+        
+        if not result or result[0] is None:
+            logger.error("Processing failed - no result")
+            return {"error": "Processing failed"}, None
             
-            if not result or result[0] is None:
-                req_logger.error("Processing failed - no result")
-                return {"error": "Processing failed"}, None
+        info, _, (tgt_sr, audio_output) = result[0]
+        logger.debug(f"Processing complete - info: {info}")
 
-            # Get the result and return directly
-            result_tuple = result[0]
-            
-            # Check if result_tuple is in the expected format
-            if isinstance(result_tuple, tuple) and len(result_tuple) == 3:
-                info, _, (tgt_sr, audio_output) = result_tuple
-                
-                if audio_output is None:
-                    req_logger.error("No audio output generated")
-                    return {"error": "No audio output generated"}, None
+        if audio_output is None:
+            logger.error("No audio output generated")
+            return {"error": "No audio output generated"}, None
 
-                # Save the output
-                output_filename = f"output_{request_id}.wav"
-                output_path = os.path.join("outputs", output_filename)
-                os.makedirs("outputs", exist_ok=True)
+        # Save the output
+        try:
+            output_filename = f"output_{os.urandom(4).hex()}.wav"
+            output_path = os.path.join("outputs", output_filename)
+            os.makedirs("outputs", exist_ok=True)
 
-                if isinstance(audio_output, np.ndarray):
-                    req_logger.info(f"Saving numpy array output: shape={audio_output.shape}")
-                    wavfile.write(output_path, tgt_sr, audio_output)
-                else:
-                    req_logger.info("Saving raw audio output")
-                    with open(output_path, "wb") as f:
-                        f.write(audio_output)
-                
-                req_logger.info(f"Successfully saved to {output_path}")
-                return {"info": info}, output_path
+            if isinstance(audio_output, np.ndarray):
+                logger.debug(f"Saving numpy array with shape {audio_output.shape}")
+                wavfile.write(output_path, tgt_sr, audio_output)
             else:
-                req_logger.error(f"Invalid result format: {result_tuple}")
-                return {"error": "Invalid result format"}, None
+                logger.debug(f"Saving raw audio data of type {type(audio_output)}")
+                with open(output_path, "wb") as f:
+                    f.write(audio_output)
+            
+            logger.debug(f"Successfully saved to {output_path}")
+            return {"info": info}, output_path
 
-        except Exception as e:
-            req_logger.error(f"Error processing audio: {str(e)}")
-            return {"error": f"Processing error: {str(e)}"}, None
+        except Exception as save_error:
+            logger.error(f"Error saving output: {save_error}", exc_info=True)
+            return {"error": f"Error saving output: {str(save_error)}"}, None
 
     except Exception as e:
-        req_logger.error(f"Unexpected error: {str(e)}")
+        logger.error(f"Error in convert_tts: {str(e)}", exc_info=True)
         return {"error": str(e)}, None
-        
-# Create the Gradio interface with queue
+
+# Interface definition
 iface = gr.Interface(
-    fn=convert_tts,  # Remove async if it's there
+    fn=convert_tts,
     inputs=[
         gr.Dropdown(choices=get_model_names(), label="Model", interactive=True),
         gr.Audio(label="Upload Audio", type="filepath"),
@@ -115,12 +83,8 @@ iface = gr.Interface(
 ).queue()
 
 if __name__ == "__main__":
-    logger.info("Starting RVC server")
-    try:
-        iface.launch(
-            debug=True,
-            show_error=True,
-            max_threads=10
-        )
-    except Exception as e:
-        logger.error(f"Error launching server: {e}", exc_info=True)
+    iface.launch(
+        debug=True,
+        show_error=True,
+        max_threads=10
+    )