LEMM v1.0.0 - Rename and add HF repo storage persistence

MAJOR UPDATE:
- Renamed to 'LEMM - Let Everyone Make Music' v1.0.0 (beta)
- Header updated with new branding and description
- Training data now persists in HuggingFace dataset repo

Critical Fixes:
- Fixed mastering syntax error (line 439)
- Improved LyricMind model loading with retry logic
- Better placeholder warnings when model not loaded

HuggingFace Repo Integration:
- Added HFStorageService for Gamahea/lemm-dataset repo
- Auto-sync LoRAs and datasets from repo on startup
- Auto-upload trained LoRAs after training
- Auto-upload prepared datasets after preparation
- Data persists across Space rebuilds

Header Changes:
- Title: LEMM - Let Everyone Make Music
- Version 1.0.0 (beta) displayed
- New description: Advanced AI music generator with training, EQ, Mastering, Super Resolution
- Removed deprecated duration tip

Storage Flow:
- Startup: Download existing LoRAs/datasets from HF repo
- After training: Upload LoRA to repo (survives rebuilds)
- After prep: Upload dataset to repo (survives rebuilds)

Dependencies:
- Added huggingface-hub>=0.20.0

app.py

@@ -7,6 +7,7 @@ import sys
 import gradio as gr
 import logging
 from pathlib import Path
+from datetime import datetime
 import shutil
 import subprocess
 import json
@@ -52,6 +53,7 @@ try:
     from services.lyricmind_service import LyricMindService
     from services.timeline_service import TimelineService
     from services.export_service import ExportService
+    from services.hf_storage_service import HFStorageService
     from config.settings import Config
     from utils.prompt_analyzer import PromptAnalyzer
 except ImportError as e:
@@ -72,6 +74,15 @@ os.makedirs("logs", exist_ok=True)
 timeline_service = TimelineService()
 export_service = ExportService()
 
+# Initialize HF storage and sync training data
+hf_storage = HFStorageService(repo_id="Gamahea/lemm-dataset")
+logger.info("🔄 Syncing training data from HuggingFace repo...")
+sync_result = hf_storage.sync_on_startup(
+    loras_dir=Path("models/loras"),
+    datasets_dir=Path("training_data")
+)
+logger.info(f"✅ Synced {len(sync_result['loras'])} LoRAs and {len(sync_result['datasets'])} datasets")
+
 # Lazy-load AI services (heavy models)
 diffrhythm_service = None
 lyricmind_service = None
@@ -438,6 +449,8 @@ def export_timeline(filename: str, export_format: str, timeline_state: dict, pro
 def get_timeline_playback(timeline_state: dict):
     """Get merged timeline audio for playback"""
     try:
+        logger.info(f"[PLAYBACK] get_timeline_playback called with state: {timeline_state is not None}")
+        
         # Restore timeline from state
         if timeline_state and 'clips' in timeline_state:
             timeline_service.clips = []
@@ -445,11 +458,15 @@ def get_timeline_playback(timeline_state: dict):
                 from models.schemas import TimelineClip
                 clip = TimelineClip(**clip_data)
                 timeline_service.clips.append(clip)
-            logger.info(f"[STATE] Restored {len(timeline_service.clips)} clips for playback")
+            logger.info(f"[PLAYBACK] Restored {len(timeline_service.clips)} clips from state")
+        else:
+            logger.warning(f"[PLAYBACK] No valid timeline_state provided: {timeline_state}")
         
         clips = timeline_service.get_all_clips()
+        logger.info(f"[PLAYBACK] Total clips in timeline: {len(clips)}")
         
         if not clips:
+            logger.warning("[PLAYBACK] No clips available for playback")
             return None
         
         # Use export service to merge clips
@@ -459,7 +476,7 @@ def get_timeline_playback(timeline_state: dict):
             export_format="wav"
         )
         
-        logger.info(f"Timeline playback ready: {output_path}")
+        logger.info(f"[PLAYBACK] Timeline playback ready: {output_path}")
         return output_path
         
     except Exception as e:
@@ -1165,6 +1182,16 @@ def prepare_datasets_for_training(selected_datasets, max_samples_per_dataset):
         if success_count > 0:
             status_messages.append(f"\n✅ Datasets are now ready for LoRA training!")
             status_messages.append(f"💡 Go to 'Training Configuration' tab to start training")
+            
+            # Upload prepared datasets to HF repo
+            status_messages.append(f"\n📤 Uploading prepared datasets to HuggingFace repo...")
+            upload_count = 0
+            for dataset_key in datasets_to_process:
+                dataset_dir = Path("training_data") / dataset_key
+                if dataset_dir.exists():
+                    if hf_storage.upload_dataset(dataset_dir):
+                        upload_count += 1
+            status_messages.append(f"✅ Uploaded {upload_count} dataset(s) to repo")
         
         return "\n".join(status_messages)
         
@@ -1301,23 +1328,6 @@ def refresh_dataset_list():
         logger.error(f"Failed to refresh datasets: {e}")
         return gr.Dropdown(choices=["Error loading datasets"])
 
-def refresh_lora_list():
-    """Refresh list of available LoRA adapters"""
-    try:
-        from backend.services.lora_training_service import LoRATrainingService
-        lora_service = LoRATrainingService()
-        
-        loras = lora_service.list_loras()
-        
-        if not loras:
-            return gr.Dropdown(choices=["No LoRA adapters found"], value=None)
-        
-        return gr.Dropdown(choices=loras, value=loras[0] if loras else None)
-        
-    except Exception as e:
-        logger.error(f"Failed to refresh LoRAs: {e}")
-        return gr.Dropdown(choices=["Error loading LoRAs"], value=None)
-
 def start_lora_training(lora_name, dataset, batch_size, learning_rate, num_epochs, lora_rank, lora_alpha):
     """Start LoRA training"""
     try:
@@ -1367,6 +1377,16 @@ def start_lora_training(lora_name, dataset, batch_size, learning_rate, num_epoch
         progress += f"\n✅ Training complete!\nFinal validation loss: {results['final_val_loss']:.4f}"
         log += f"\n\nTraining Results:\n{json.dumps(results, indent=2)}"
         
+        # Upload trained LoRA to HF repo
+        progress += "\n\n📤 Uploading LoRA to HuggingFace repo..."
+        lora_dir = Path("models/loras") / lora_name
+        if lora_dir.exists():
+            upload_success = hf_storage.upload_lora(lora_dir)
+            if upload_success:
+                progress += "\n✅ LoRA uploaded to repo successfully!"
+            else:
+                progress += "\n⚠️ LoRA trained but upload failed (saved locally)"
+        
         return progress, log
         
     except Exception as e:
@@ -1407,11 +1427,12 @@ def refresh_lora_list():
             ])
             lora_names.append(adapter.get('name', ''))
         
-        return table_data, gr.Dropdown(choices=lora_names)
+        # Return table data and update both dropdowns (action dropdown and base_lora dropdown)
+        return table_data, gr.Dropdown(choices=lora_names), gr.Dropdown(choices=lora_names)
         
     except Exception as e:
         logger.error(f"Failed to refresh LoRA list: {e}")
-        return [], gr.Dropdown(choices=[])
+        return [], gr.Dropdown(choices=[]), gr.Dropdown(choices=[])
 
 def delete_lora(lora_name):
     """Delete selected LoRA adapter"""
@@ -1433,19 +1454,124 @@ def delete_lora(lora_name):
         logger.error(f"Failed to delete LoRA: {e}")
         return f"❌ Error: {str(e)}"
 
+def download_lora(lora_name):
+    """Export LoRA adapter as zip file for download"""
+    try:
+        if not lora_name:
+            return None, "❌ No LoRA selected"
+        
+        from backend.services.lora_training_service import LoRATrainingService
+        lora_service = LoRATrainingService()
+        
+        zip_path = lora_service.export_lora_adapter(lora_name)
+        
+        if zip_path:
+            # Return the file path for Gradio to handle the download
+            return zip_path, f"✅ Ready to download: {lora_name}.zip (click the file above to download)"
+        else:
+            return None, f"❌ Failed to export: {lora_name}"
+        
+    except Exception as e:
+        logger.error(f"Failed to export LoRA: {e}")
+        return None, f"❌ Error: {str(e)}"
+
+def upload_lora(zip_file):
+    """Import LoRA adapter from zip file"""
+    try:
+        if not zip_file:
+            return "❌ No file selected"
+        
+        from backend.services.lora_training_service import LoRATrainingService
+        lora_service = LoRATrainingService()
+        
+        lora_name = lora_service.import_lora_adapter(zip_file)
+        
+        if lora_name:
+            return f"✅ Imported LoRA adapter: {lora_name}"
+        else:
+            return "❌ Failed to import LoRA"
+        
+    except Exception as e:
+        logger.error(f"Failed to import LoRA: {e}")
+        return f"❌ Error: {str(e)}"
+
+def toggle_base_lora(use_existing):
+    """Toggle visibility of base LoRA adapter dropdown"""
+    return gr.Dropdown(visible=use_existing)
+
+def export_dataset(dataset_key):
+    """Export prepared dataset as zip file"""
+    try:
+        if not dataset_key:
+            return None, "❌ No dataset selected"
+        
+        from backend.services.dataset_service import DatasetService
+        dataset_service = DatasetService()
+        
+        zip_path = dataset_service.export_prepared_dataset(dataset_key)
+        
+        if zip_path:
+            return zip_path, f"✅ Dataset exported: {dataset_key}.zip"
+        else:
+            return None, f"❌ Failed to export: {dataset_key}"
+        
+    except Exception as e:
+        logger.error(f"Failed to export dataset: {e}")
+        return None, f"❌ Error: {str(e)}"
+
+def import_dataset(zip_file):
+    """Import prepared dataset from zip file"""
+    try:
+        if not zip_file:
+            return "❌ No file selected"
+        
+        from backend.services.dataset_service import DatasetService
+        dataset_service = DatasetService()
+        
+        dataset_key = dataset_service.import_prepared_dataset(zip_file)
+        
+        if dataset_key:
+            return f"✅ Imported dataset: {dataset_key}"
+        else:
+            return "❌ Failed to import dataset"
+        
+    except Exception as e:
+        logger.error(f"Failed to import dataset: {e}")
+        return f"❌ Error: {str(e)}"
+
+def refresh_export_dataset_list():
+    """Refresh list of datasets available for export"""
+    try:
+        from backend.services.dataset_service import DatasetService
+        dataset_service = DatasetService()
+        
+        # Get all available datasets (both HF and user)
+        all_datasets = dataset_service.get_all_available_datasets()
+        
+        # Filter to only prepared datasets
+        prepared = []
+        for key, info in all_datasets.items():
+            if info.get('prepared', False):
+                prepared.append(key)
+        
+        return gr.Dropdown(choices=prepared)
+        
+    except Exception as e:
+        logger.error(f"Failed to refresh export list: {e}")
+        return gr.Dropdown(choices=[])
+
 # Create Gradio interface
 with gr.Blocks(
-    title="🎵 Music Generation Studio",
+    title="LEMM - Let Everyone Make Music v1.0.0 (beta)",
     theme=gr.themes.Soft(primary_hue="purple", secondary_hue="pink")
 ) as app:
     
     gr.Markdown(
         """
-        # 🎵 Music Generation Studio
+        # 🎵 LEMM - Let Everyone Make Music
+        **Version 1.0.0 (beta)**
         
-        Create AI-powered music with DiffRhythm2 and LyricMind AI
-        
-        💡 **Tip**: Start with 10-20 second clips for faster generation with ZeroGPU
+        Advanced AI music generator with built-in training, EQ, Mastering, and Super Resolution. Training data is stored safely on a separate repo for download / reuse.
         """
     )
     
@@ -1732,6 +1858,10 @@ with gr.Blocks(
         fn=generate_music,
         inputs=[prompt_input, lyrics_input, lyrics_mode, position_input, context_length_input, timeline_state],
         outputs=[gen_status, timeline_display, audio_output, timeline_state]
+    ).then(
+        fn=get_timeline_playback,
+        inputs=[timeline_state],
+        outputs=[timeline_playback]
     )
     
     remove_btn.click(
@@ -1948,6 +2078,27 @@ with gr.Blocks(
                 
                 prepare_user_dataset_btn = gr.Button("📦 Prepare Training Dataset", variant="primary")
                 user_prepare_status = gr.Textbox(label="Preparation Status", lines=2, interactive=False)
+                
+                gr.Markdown("---")
+                gr.Markdown("### 📤 Dataset Import/Export")
+                
+                with gr.Row():
+                    dataset_to_export = gr.Dropdown(
+                        choices=[],
+                        label="Select Dataset to Export",
+                        info="Download prepared datasets"
+                    )
+                    export_dataset_btn = gr.Button("⬇️ Export Dataset", variant="primary", size="sm")
+                
+                with gr.Row():
+                    import_dataset_file = gr.File(
+                        label="Import Dataset (.zip)",
+                        file_types=[".zip"],
+                        type="filepath"
+                    )
+                
+                dataset_download_file = gr.File(label="Downloaded Dataset", visible=True, interactive=False)
+                dataset_export_status = gr.Textbox(label="Export/Import Status", lines=2, interactive=False)
             
             # Tab 3: Training Configuration
             with gr.Tab("⚙️ Training Configuration"):
@@ -1967,6 +2118,21 @@ with gr.Blocks(
                 
                 refresh_datasets_btn = gr.Button("🔄 Refresh Datasets", size="sm")
                 
+                gr.Markdown("#### Fine-tune Existing LoRA (Optional)")
+                
+                use_existing_lora = gr.Checkbox(
+                    label="Continue training from existing LoRA",
+                    value=False,
+                    info="Start from a pre-trained LoRA adapter instead of from scratch"
+                )
+                
+                base_lora_adapter = gr.Dropdown(
+                    choices=[],
+                    label="Base LoRA Adapter",
+                    info="Select LoRA to continue training from",
+                    visible=False
+                )
+                
                 gr.Markdown("#### Hyperparameters")
                 
                 with gr.Row():
@@ -2036,25 +2202,47 @@ with gr.Blocks(
             
             # Tab 4: Manage LoRA Adapters
             with gr.Tab("📂 Manage LoRA Adapters"):
+                gr.Markdown("### Upload New LoRA Adapter")
+                
+                with gr.Row():
+                    upload_lora_file = gr.File(
+                        label="📤 Upload LoRA (.zip)",
+                        file_types=[".zip"],
+                        type="filepath",
+                        scale=3
+                    )
+                    upload_lora_btn = gr.Button("Upload", variant="primary", size="sm")
+                
+                upload_lora_status = gr.Textbox(label="Upload Status", lines=1, interactive=False)
+                
+                gr.Markdown("---")
                 gr.Markdown("### Installed LoRA Adapters")
                 
                 lora_list = gr.Dataframe(
                     headers=["Name", "Created", "Training Steps", "Type"],
                     datatype=["str", "str", "number", "str"],
                     row_count=10,
-                    label="Available LoRA Adapters"
+                    label="Available LoRA Adapters",
+                    interactive=False
                 )
                 
                 with gr.Row():
                     refresh_lora_btn = gr.Button("🔄 Refresh List", size="sm")
-                    selected_lora = gr.Dropdown(
-                        choices=[],
-                        label="Select LoRA",
-                        scale=2
-                    )
-                    delete_lora_btn = gr.Button("🗑️ Delete LoRA", variant="stop", size="sm")
                 
-                lora_management_status = gr.Textbox(label="Status", lines=1, interactive=False)
+                gr.Markdown("### Actions on Selected LoRA")
+                
+                selected_lora_for_action = gr.Dropdown(
+                    choices=[],
+                    label="Select LoRA Adapter",
+                    info="Choose a LoRA to download or delete"
+                )
+                
+                with gr.Row():
+                    download_lora_btn = gr.Button("⬇️ Download LoRA", variant="primary", size="lg", scale=1)
+                    delete_lora_btn = gr.Button("🗑️ Delete LoRA", variant="stop", size="lg", scale=1)
+                
+                lora_download_file = gr.File(label="Downloaded LoRA", interactive=False)
+                lora_action_status = gr.Textbox(label="Action Status", lines=1, interactive=False)
                 
                 gr.Markdown("---")
                 gr.Markdown(
@@ -2171,17 +2359,63 @@ with gr.Blocks(
     refresh_lora_btn.click(
         fn=refresh_lora_list,
         inputs=[],
-        outputs=[lora_list, selected_lora]
+        outputs=[lora_list, selected_lora_for_action, base_lora_adapter]
     )
     
     delete_lora_btn.click(
         fn=delete_lora,
-        inputs=[selected_lora],
-        outputs=[lora_management_status]
+        inputs=[selected_lora_for_action],
+        outputs=[lora_action_status]
+    ).then(
+        fn=refresh_lora_list,
+        inputs=[],
+        outputs=[lora_list, selected_lora_for_action, base_lora_adapter]
+    )
+    
+    download_lora_btn.click(
+        fn=download_lora,
+        inputs=[selected_lora_for_action],
+        outputs=[lora_download_file, lora_action_status]
+    )
+    
+    upload_lora_btn.click(
+        fn=upload_lora,
+        inputs=[upload_lora_file],
+        outputs=[upload_lora_status]
     ).then(
         fn=refresh_lora_list,
         inputs=[],
-        outputs=[lora_list, selected_lora]
+        outputs=[lora_list, selected_lora_for_action, base_lora_adapter]
+    )
+    
+    use_existing_lora.change(
+        fn=toggle_base_lora,
+        inputs=[use_existing_lora],
+        outputs=[base_lora_adapter]
+    )
+    
+    export_dataset_btn.click(
+        fn=export_dataset,
+        inputs=[dataset_to_export],
+        outputs=[dataset_download_file, dataset_export_status]
+    )
+    
+    import_dataset_file.change(
+        fn=import_dataset,
+        inputs=[import_dataset_file],
+        outputs=[dataset_export_status]
+    ).then(
+        fn=refresh_dataset_status,
+        inputs=[],
+        outputs=[vocal_datasets, symbolic_datasets, prepare_datasets_selector]
+    ).then(
+        fn=refresh_dataset_list,
+        inputs=[],
+        outputs=[selected_dataset]
+    ).then(
+        fn=refresh_export_dataset_list,
+        inputs=[],
+        outputs=[dataset_to_export]
     )
     
     # Help section

backend/services/hf_storage_service.py

@@ -0,0 +1,234 @@
+"""
+HuggingFace Dataset Repository Storage Service
+Stores and retrieves training data and LoRA adapters from HF dataset repo
+"""
+import os
+import logging
+from pathlib import Path
+from typing import List, Dict, Optional
+import shutil
+
+logger = logging.getLogger(__name__)
+
+class HFStorageService:
+    """Service for storing/retrieving data from HuggingFace dataset repo"""
+    
+    def __init__(self, repo_id: str = "Gamahea/lemm-dataset"):
+        """
+        Initialize HF storage service
+        
+        Args:
+            repo_id: HuggingFace dataset repository ID
+        """
+        self.repo_id = repo_id
+        self.local_cache = Path("hf_cache")
+        self.local_cache.mkdir(exist_ok=True)
+        
+        logger.info(f"HF Storage initialized for repo: {repo_id}")
+        
+        # Try to import huggingface_hub
+        try:
+            from huggingface_hub import HfApi, hf_hub_download, upload_folder
+            self.api = HfApi()
+            self.has_hf = True
+            logger.info("✅ HuggingFace Hub available")
+        except ImportError:
+            logger.warning("⚠️ huggingface_hub not available, using local storage only")
+            self.has_hf = False
+    
+    def download_all_loras(self, target_dir: Path) -> List[str]:
+        """
+        Download all LoRA adapters from HF repo
+        
+        Args:
+            target_dir: Local directory to download to
+            
+        Returns:
+            List of downloaded LoRA names
+        """
+        if not self.has_hf:
+            logger.warning("HuggingFace Hub not available")
+            return []
+        
+        try:
+            from huggingface_hub import snapshot_download
+            
+            logger.info(f"Downloading LoRAs from {self.repo_id}/loras...")
+            
+            # Download loras folder
+            loras_path = snapshot_download(
+                repo_id=self.repo_id,
+                repo_type="dataset",
+                allow_patterns="loras/*",
+                local_dir=self.local_cache,
+                local_dir_use_symlinks=False
+            )
+            
+            # Copy to target directory
+            source_loras = Path(loras_path) / "loras"
+            if source_loras.exists():
+                target_dir.mkdir(parents=True, exist_ok=True)
+                
+                downloaded = []
+                for lora_dir in source_loras.iterdir():
+                    if lora_dir.is_dir():
+                        dest = target_dir / lora_dir.name
+                        if dest.exists():
+                            shutil.rmtree(dest)
+                        shutil.copytree(lora_dir, dest)
+                        downloaded.append(lora_dir.name)
+                        logger.info(f"Downloaded LoRA: {lora_dir.name}")
+                
+                return downloaded
+            
+            return []
+            
+        except Exception as e:
+            logger.error(f"Failed to download LoRAs: {e}")
+            return []
+    
+    def download_all_datasets(self, target_dir: Path) -> List[str]:
+        """
+        Download all prepared datasets from HF repo
+        
+        Args:
+            target_dir: Local directory to download to
+            
+        Returns:
+            List of downloaded dataset keys
+        """
+        if not self.has_hf:
+            logger.warning("HuggingFace Hub not available")
+            return []
+        
+        try:
+            from huggingface_hub import snapshot_download
+            
+            logger.info(f"Downloading datasets from {self.repo_id}/datasets...")
+            
+            # Download datasets folder
+            datasets_path = snapshot_download(
+                repo_id=self.repo_id,
+                repo_type="dataset",
+                allow_patterns="datasets/*",
+                local_dir=self.local_cache,
+                local_dir_use_symlinks=False
+            )
+            
+            # Copy to target directory
+            source_datasets = Path(datasets_path) / "datasets"
+            if source_datasets.exists():
+                target_dir.mkdir(parents=True, exist_ok=True)
+                
+                downloaded = []
+                for dataset_dir in source_datasets.iterdir():
+                    if dataset_dir.is_dir():
+                        dest = target_dir / dataset_dir.name
+                        if dest.exists():
+                            shutil.rmtree(dest)
+                        shutil.copytree(dataset_dir, dest)
+                        downloaded.append(dataset_dir.name)
+                        logger.info(f"Downloaded dataset: {dataset_dir.name}")
+                
+                return downloaded
+            
+            return []
+            
+        except Exception as e:
+            logger.error(f"Failed to download datasets: {e}")
+            return []
+    
+    def upload_lora(self, lora_dir: Path) -> bool:
+        """
+        Upload a LoRA adapter to HF repo
+        
+        Args:
+            lora_dir: Local LoRA directory
+            
+        Returns:
+            True if successful
+        """
+        if not self.has_hf:
+            logger.warning("HuggingFace Hub not available")
+            return False
+        
+        try:
+            from huggingface_hub import upload_folder
+            
+            logger.info(f"Uploading LoRA {lora_dir.name} to {self.repo_id}...")
+            
+            upload_folder(
+                repo_id=self.repo_id,
+                repo_type="dataset",
+                folder_path=str(lora_dir),
+                path_in_repo=f"loras/{lora_dir.name}",
+                commit_message=f"Add/Update LoRA: {lora_dir.name}"
+            )
+            
+            logger.info(f"✅ Uploaded LoRA: {lora_dir.name}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to upload LoRA: {e}")
+            return False
+    
+    def upload_dataset(self, dataset_dir: Path) -> bool:
+        """
+        Upload a prepared dataset to HF repo
+        
+        Args:
+            dataset_dir: Local dataset directory
+            
+        Returns:
+            True if successful
+        """
+        if not self.has_hf:
+            logger.warning("HuggingFace Hub not available")
+            return False
+        
+        try:
+            from huggingface_hub import upload_folder
+            
+            logger.info(f"Uploading dataset {dataset_dir.name} to {self.repo_id}...")
+            
+            upload_folder(
+                repo_id=self.repo_id,
+                repo_type="dataset",
+                folder_path=str(dataset_dir),
+                path_in_repo=f"datasets/{dataset_dir.name}",
+                commit_message=f"Add/Update dataset: {dataset_dir.name}"
+            )
+            
+            logger.info(f"✅ Uploaded dataset: {dataset_dir.name}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to upload dataset: {e}")
+            return False
+    
+    def sync_on_startup(self, loras_dir: Path, datasets_dir: Path) -> Dict[str, List[str]]:
+        """
+        Sync data from HF repo on app startup
+        
+        Args:
+            loras_dir: Local LoRA directory
+            datasets_dir: Local datasets directory
+            
+        Returns:
+            Dict with 'loras' and 'datasets' lists
+        """
+        result = {'loras': [], 'datasets': []}
+        
+        logger.info("🔄 Syncing from HuggingFace repo...")
+        
+        # Download LoRAs
+        loras = self.download_all_loras(loras_dir)
+        result['loras'] = loras
+        
+        # Download datasets
+        datasets = self.download_all_datasets(datasets_dir)
+        result['datasets'] = datasets
+        
+        logger.info(f"✅ Sync complete: {len(loras)} LoRAs, {len(datasets)} datasets")
+        
+        return result

backend/services/lyricmind_service.py

@@ -109,10 +109,21 @@ class LyricMindService:
             
             # Try to generate with text model
             if self.model is not None and self.tokenizer is not None:
+                logger.info("Using AI model for lyrics generation")
                 lyrics = self._generate_with_model(prompt, effective_style, duration, analysis)
             else:
-                # Fallback: placeholder lyrics
-                lyrics = self._generate_placeholder(prompt, effective_style, duration)
+                logger.warning("AI model not available, attempting to load...")
+                # Try to initialize again before falling back
+                try:
+                    self.is_initialized = False
+                    self._initialize_model()
+                    if self.model is not None:
+                        lyrics = self._generate_with_model(prompt, effective_style, duration, analysis)
+                    else:
+                        lyrics = self._generate_placeholder(prompt, effective_style, duration)
+                except:
+                    logger.error("Failed to load AI model, using placeholder")
+                    lyrics = self._generate_placeholder(prompt, effective_style, duration)
             
             logger.info("Lyrics generated successfully")
             return lyrics
@@ -198,7 +209,9 @@ class LyricMindService:
         Returns:
             Placeholder lyrics
         """
-        logger.warning("Using placeholder lyrics - LyricMind model not loaded")
+        logger.warning("⚠️ PLACEHOLDER LYRICS - LyricMind AI model not loaded")
+        logger.warning(f"Model path checked: {self.model_path}")
+        logger.warning("Please ensure text_generator model is available in models/ directory")
         
         # Estimate number of lines based on duration
         lines_per_30s = 8
@@ -210,9 +223,9 @@ class LyricMindService:
             f"Style: {style}",
             "",
             "[Chorus]",
-            "This is a placeholder",
-            "Generated by LyricMind AI",
-            "Replace with actual model output",
+            "⚠️ PLACEHOLDER - Model not loaded",
+            "LyricMind AI requires text_generator model",
+            "Check logs for model loading errors",
         ]
         
         # Pad to desired length

backend/services/mastering_service.py

@@ -436,19 +436,6 @@ class MasteringService:
     def __init__(self):
         """Initialize mastering service"""
         logger.info("Mastering service initialized")
-            "Retro 80s",
-            "80s digital warmth and punch",
-            [
-                HighpassFilter(cutoff_frequency_hz=35),
-                LowShelfFilter(cutoff_frequency_hz=100, gain_db=1.5, q=0.7),
-                PeakFilter(cutoff_frequency_hz=800, gain_db=1.0, q=1.0),
-                PeakFilter(cutoff_frequency_hz=3000, gain_db=2.0, q=1.2),
-                PeakFilter(cutoff_frequency_hz=8000, gain_db=1.5, q=1.0),
-                HighShelfFilter(cutoff_frequency_hz=10000, gain_db=1.0, q=0.8),
-                Compressor(threshold_db=-10, ratio=4.0, attack_ms=5, release_ms=100),
-                Limiter(threshold_db=-0.5, release_ms=80)
-            ]
-        ),
         
         # Specialized Presets
         "vocal_focused": MasteringPreset(

requirements.txt

@@ -1,36 +1,41 @@
-# Core dependencies for HuggingFace Spaces deployment
-gradio==4.44.0
-spaces>=0.28.3
-numpy>=1.24.0,<2.0.0
+# Core dependencies
+flask>=3.0.0
+flask-cors>=4.0.0
+gradio>=4.0.0
+huggingface-hub>=0.20.0  # For HF dataset repo storage
+numpy>=1.24.0
 scipy>=1.10.0
 librosa>=0.10.0
 soundfile>=0.12.0
 pydantic>=2.0.0
+python-dotenv>=1.0.0
 pyyaml>=6.0
+requests>=2.31.0
 
-# PyTorch - GPU mode for ZeroGPU
-torch>=2.4.0,<2.5.0
-torchaudio>=2.4.0,<2.5.0
+# PyTorch - CPU mode for compatibility
+# Note: DiffRhythm2 requires torch>=2.4 which is incompatible with torch-directml
+# Using CPU mode to avoid version conflicts. For GPU acceleration, use NVIDIA CUDA.
+torch>=2.4.0
+torchaudio>=2.4.0
 
-# DiffRhythm2 dependencies
-torchdiffeq>=0.2.4
+# DiffRhythm 2 core dependencies
+torchdiffeq>=0.2.4  # Required for CFM (flow matching)
 phonemizer>=3.2.0
-muq>=0.1.0
-jieba>=0.42.0
-pypinyin>=0.50.0
-cn2an>=0.5.0
-onnxruntime>=1.15.0
-pykakasi>=2.3.0
-unidecode>=1.3.0
-py3langid>=0.2.2
-pyopenjtalk>=0.3.0
-inflect>=7.0.0
+muq>=0.1.0  # MuQ-MuLan style encoder for music generation
+jieba>=0.42.0  # Chinese text segmentation
+pypinyin>=0.50.0  # Chinese to pinyin conversion
+cn2an>=0.5.0  # Chinese number to text
+onnxruntime>=1.15.0  # For g2p Chinese model
+pykakasi>=2.3.0  # Japanese text processing
+pyopenjtalk; python_version < "3.12"  # Japanese phonetics (Python 3.11 compatible)
+unidecode>=1.3.0  # Text normalization
+py3langid>=0.2.2  # Language detection
 
 # AI Model dependencies
-transformers==4.47.1
+transformers==4.47.1  # Pinned for DiffRhythm2 compatibility
 diffusers>=0.21.0
 sentencepiece>=0.1.99
-protobuf>=3.20.0,<5.0.0
+protobuf>=3.20.0
 accelerate>=0.20.0
 einops>=0.7.0
 omegaconf>=2.3.0
@@ -40,15 +45,19 @@ pedalboard>=0.7.0
 pydub>=0.25.1
 resampy>=0.4.2
 
+# Audio quality enhancement
+demucs==4.0.1  # Stem separation
+noisereduce>=3.0.0  # Noise reduction
+audiosr>=0.0.7  # Audio super resolution (upscaling to 48kHz)
+
 # LoRA Training dependencies
 peft>=0.6.0  # Parameter-Efficient Fine-Tuning (LoRA adapters)
 datasets>=2.14.0  # HuggingFace datasets for training data management
 tensorboard>=2.13.0  # Training monitoring and visualization
+wandb>=0.15.0  # Optional: Advanced experiment tracking
 
 # Utilities
 tqdm>=4.65.0
 huggingface-hub>=0.17.0
 safetensors>=0.3.0
-
-# System dependencies note:
-# espeak-ng is required by phonemizer and should be installed via packages.txt
+gitpython>=3.1.0