Update gui.py

gui.py

@@ -12,36 +12,40 @@ import soundfile as sf
 from ensemble import ensemble_files
 import shutil
 import gradio_client.utils as client_utils
+import validators
+import matchering as mg
+from typing import Any, Optional
 
-# Patch gradio_client.utils.get_type to handle boolean schemas
-def patched_get_type(schema):
+# Logging setup
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Patch gradio_client.utils._json_schema_to_python_type to handle enum schemas
+original_json_schema_to_python_type = client_utils._json_schema_to_python_type
+
+def patched_json_schema_to_python_type(schema: Any, defs: Optional[dict] = None) -> str:
+    logger.debug(f"Parsing schema: {schema}")
     if isinstance(schema, bool):
+        logger.info("Found boolean schema, returning 'boolean'")
         return "boolean"
-    if "const" in schema:
-        return repr(schema["const"])
-    if "enum" in schema:
-        return f"Union[{', '.join(repr(e) for e in schema['enum'])}]"
-    if "type" not in schema:
+    if not isinstance(schema, dict):
+        logger.warning(f"Unexpected schema type: {type(schema)}, returning 'Any'")
         return "Any"
-    type_ = schema["type"]
-    if isinstance(type_, list):
-        return f"Union[{', '.join(t for t in type_ if t != 'null')}]"
-    if type_ == "array":
-        return f"List[{client_utils._json_schema_to_python_type(schema.get('items', {}), schema.get('$defs', {}))}]"
-    if type_ == "object":
-        return "Dict[str, Any]"
-    return type_
+    if "enum" in schema and schema.get("type") == "string":
+        logger.info(f"Handling enum schema: {schema['enum']}")
+        return f"Literal[{', '.join(repr(e) for e in schema['enum'])}]"
+    try:
+        return original_json_schema_to_python_type(schema, defs)
+    except client_utils.APIInfoParseError as e:
+        logger.error(f"Failed to parse schema {schema}: {e}")
+        return "str"  # Fallback to str for string enums
 
-client_utils.get_type = patched_get_type
+client_utils._json_schema_to_python_type = patched_json_schema_to_python_type
 
 # Device and autocast setup
 device = "cuda" if torch.cuda.is_available() else "cpu"
 use_autocast = device == "cuda"
 
-# Logging setup
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
 # Model dictionaries organized by category
 ROFORMER_MODELS = {
     "Vocals": {
@@ -136,7 +140,7 @@ ROFORMER_MODELS = {
 
 OUTPUT_FORMATS = ['wav', 'flac', 'mp3', 'ogg', 'opus', 'm4a', 'aiff', 'ac3']
 
-# CSS for UI styling
+# CSS for UI styling (unchanged from previous)
 CSS = """
 /* Modern ve Etkileşimli Tema */
 #app-container {
@@ -353,8 +357,8 @@ button:hover {
 # Functions
 def download_audio(url, out_dir="ytdl"):
     """Download audio from a URL using yt-dlp."""
-    if not url:
-        raise ValueError("No URL provided.")
+    if not url or not validators.url(url):
+        raise ValueError("Invalid or missing URL.")
     
     if os.path.exists(out_dir):
         shutil.rmtree(out_dir)
@@ -371,6 +375,7 @@ def download_audio(url, out_dir="ytdl"):
             info_dict = ydl.extract_info(url, download=True)
             return ydl.prepare_filename(info_dict).rsplit('.', 1)[0] + '.wav'
     except Exception as e:
+        logger.error(f"Download failed: {e}")
         raise RuntimeError(f"Download failed: {e}")
 
 def roformer_separator(audio, model_key, seg_size, override_seg_size, overlap, pitch_shift, model_dir, output_dir, out_format, norm_thresh, amp_thresh, batch_size, exclude_stems="", progress=gr.Progress(track_tqdm=True)):
@@ -489,11 +494,15 @@ def auto_ensemble_process(audio, model_keys, seg_size, overlap, out_format, use_
 
 def update_roformer_models(category):
     """Update Roformer model dropdown based on selected category."""
-    return gr.update(choices=list(ROFORMER_MODELS.get(category, {}).keys()) or [])
+    choices = list(ROFORMER_MODELS.get(category, {}).keys()) or []
+    logger.debug(f"Updating roformer models for category {category}: {choices}")
+    return gr.update(choices=choices)
 
 def update_ensemble_models(category):
     """Update ensemble model dropdown based on selected category."""
-    return gr.update(choices=list(ROFORMER_MODELS.get(category, {}).keys()) or [])
+    choices = list(ROFORMER_MODELS.get(category, {}).keys()) or []
+    logger.debug(f"Updating ensemble models for category {category}: {choices}")
+    return gr.update(choices=choices)
 
 # Interface creation
 def create_interface():
@@ -507,7 +516,7 @@ def create_interface():
                 with gr.Group(elem_classes="dubbing-theme"):
                     gr.Markdown("### General Settings")
                     model_file_dir = gr.Textbox(value="/tmp/audio-separator-models/", label="📂 Model Cache", placeholder="Path to model directory", interactive=True)
-                    output_dir = gr.Textbox(value="output", label="📤 Output Directory", placeholder="Where to save results", interactive=True)
+                    output_dir = gr.Textbox(value="output+*6", label="📤 Output Directory", placeholder="Where to save results", interactive=True)
                     output_format = gr.Dropdown(value="wav", choices=OUTPUT_FORMATS, label="🎶 Output Format", interactive=True)
                     norm_threshold = gr.Slider(0.1, 1.0, value=0.9, step=0.1, label="🔊 Normalization Threshold", interactive=True)
                     amp_threshold = gr.Slider(0.1, 1.0, value=0.3, step=0.1, label="📈 Amplification Threshold", interactive=True)
@@ -594,7 +603,7 @@ if __name__ == "__main__":
 
     app = create_interface()
     try:
-        # For Hugging Face Spaces or local testing
+        # For Hugging Face Spaces
         app.launch(server_name="0.0.0.0", server_port=args.port, share=True)
     except Exception as e:
         logger.error(f"Failed to launch app: {e}")