workaround for gradio file permission -attempt

main.py

@@ -14,7 +14,10 @@ from audiocraft.data.audio_utils import f32_pcm, normalize_audio
 from audiocraft.data.audio import audio_write
 from audiocraft.models import JASCO
 import os
+import tempfile
 from huggingface_hub import login
+from pathlib import Path
+
 
 title = """# 🙋🏻‍♂️Welcome to 🌟Tonic's 🎼Jasco🎶AudioCraft Demo"""
 description = """Facebook presents JASCO, a temporally controlled text-to-music generation model utilizing both symbolic and audio-based conditions. JASCO can generate high-quality music samples conditioned on global text descriptions along with fine-grained local controls. JASCO is based on the Flow Matching modeling paradigm together with a novel conditioning method, allowing for music generation controlled both locally (e.g., chords) and globally (text description). [run this demo locally](https://huggingface.co/spaces/Tonic/audiocraft?docker=true) or [embed this space](https://huggingface.co/spaces/Tonic/audiocraft?embed=true) or [duplicate this space](https://huggingface.co/spaces/Tonic/audiocraft?duplicate=true) to run it privately . you can also use this demo via API by clicking the link at the bottom of the page."""
@@ -187,15 +190,37 @@ Model: facebook/jasco-chords-drums-1B
 - Melody-enabled models may be slower
 """
 
+MODEL = None
+INTERRUPTING = False
+
 hf_token = os.environ.get('HFTOKEN')
 if hf_token:
     login(token=hf_token)
 
-MODEL = None
-MAX_BATCH_SIZE = 12
-INTERRUPTING = False
+# Set up cache directory
+CACHE_DIR = os.path.join(tempfile.gettempdir(), 'audiocraft_cache')
+os.makedirs(CACHE_DIR, exist_ok=True)
+
+# Set environment variables
+os.environ['AUDIOCRAFT_CACHE_DIR'] = CACHE_DIR
+os.environ['TORCH_HOME'] = CACHE_DIR
+os.environ['HF_HOME'] = os.path.join(CACHE_DIR, 'huggingface')
+os.environ['TRANSFORMERS_CACHE'] = os.path.join(CACHE_DIR, 'transformers')
+os.environ['XDG_CACHE_HOME'] = CACHE_DIR
+
+# Create necessary subdirectories
+for subdir in ['models', 'cache', 'huggingface', 'drum_cache', 'transformers']:
+    os.makedirs(os.path.join(CACHE_DIR, subdir), exist_ok=True)
 
-os.makedirs(os.path.join(os.path.dirname(__file__), "models"), exist_ok=True)
+def cleanup_cache():
+    """Clean up temporary cache files"""
+    try:
+        import shutil
+        if os.path.exists(CACHE_DIR):
+            shutil.rmtree(CACHE_DIR)
+        os.makedirs(CACHE_DIR, exist_ok=True)
+    except Exception as e:
+        print(f"Error cleaning cache: {e}")
 
 def generate_chord_mappings():
     # Define basic chord mappings
@@ -308,41 +333,87 @@ def chords_string_to_list(chords: str):
     chrd_times = [x.split(',') for x in chords[1:-1].split('),(')]
     return [(x[0], float(x[1])) for x in chrd_times]
 
+# Add this before model loading
+def patch_jasco_cache():
+    """Monkey patch JASCO cache initialization"""
+    from audiocraft.modules import jasco_conditioners
+    
+    original_init = jasco_conditioners.DrumConditioner.__init__
+    
+    def new_init(self, *args, **kwargs):
+        if 'cache_path' in kwargs:
+            kwargs['cache_path'] = os.path.join(CACHE_DIR, 'drum_cache')
+        return original_init(self, *args, **kwargs)
+    
+    jasco_conditioners.DrumConditioner.__init__ = new_init
+
+# Apply the patch
+patch_jasco_cache()
+
 # Create necessary directories
 os.makedirs("models", exist_ok=True)
 
 @spaces.GPU
-def load_model(version='facebook/jasco-chords-drums-400M'):
+def load_model(version='facebook/jasco-chords-drums-melody-400M'):
     global MODEL
     print("Loading model", version)
     if MODEL is None or MODEL.name != version:
         MODEL = None
-        
-        # Setup model directory
-        model_dir = os.path.join(os.path.dirname(__file__), "models")
-        os.makedirs(model_dir, exist_ok=True)
-        
-        # Generate and save chord mappings
-        chord_mapping_path = os.path.join(model_dir, "chord_to_index_mapping.pkl")
-        if not os.path.exists(chord_mapping_path):
-            chord_mapping_path = generate_chord_mappings()
-        
         try:
-            # Initialize JASCO with the chord mapping path
+            # Set up custom cache paths
+            cache_path = os.path.join(CACHE_DIR, version.replace('/', '_'))
+            os.makedirs(cache_path, exist_ok=True)
+            
+            # Set additional environment variables
+            os.environ['AUDIOCRAFT_CACHE_DIR'] = cache_path
+            os.environ['TRANSFORMERS_CACHE'] = os.path.join(cache_path, 'transformers')
+            
+            # Initialize model with custom cache configuration
+            model_kwargs = {
+                'device': 'cuda',
+                'cache_dir': cache_path,
+                'model_cache_dir': cache_path
+            }
+            
+            # Initialize chord mapping
+            mapping_file = initialize_chord_mapping()
+            os.environ['AUDIOCRAFT_CHORD_MAPPING'] = mapping_file
+            
+            # Load the model with specific cache paths
             MODEL = JASCO.get_pretrained(
                 version,
                 device='cuda',
-                chords_mapping_path=chord_mapping_path
+                cache_dir=cache_path,
+                local_files_only=False
             )
             MODEL.name = version
+            
+            # Configure model paths
+            MODEL._cache_dir = cache_path
+            
+            # Load the chord mapping
+            with open(mapping_file, 'rb') as f:
+                MODEL.chord_to_index = pickle.load(f)
+                
         except Exception as e:
             raise gr.Error(f"Error loading model: {str(e)}")
         
         if MODEL is None:
             raise gr.Error("Failed to load model")
-    
     return MODEL
 
+class ModelLoadingError(Exception):
+    pass
+
+def handle_model_error(func):
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except Exception as e:
+            print(f"Error in {func.__name__}: {str(e)}")
+            raise ModelLoadingError(f"Failed to load model: {str(e)}")
+    return wrapper
+
 @spaces.GPU
 def _do_predictions(texts, chords, melody_matrix, drum_prompt, progress=False, gradio_progress=None, **gen_kwargs):
     MODEL.set_generation_params(**gen_kwargs)
@@ -516,4 +587,13 @@ with gr.Blocks() as demo:
         outputs=[audio_output_0, audio_output_1]
     )
 
-demo.queue().launch(ssr_mode=False)
+    # Add cleanup on close
+    demo.load(lambda: None, [], [], _js="() => { window.addEventListener('beforeunload', () => { cleanup_cache(); }); }")
+# Launch with cleanup and error handling
+try:
+    demo.queue().launch(ssr_mode=False
+    )
+except Exception as e:
+    print(f"Error launching demo: {str(e)}")
+finally:
+    cleanup_cache()