Update app.py

app.py

@@ -27,7 +27,6 @@ from wordpress_xmlrpc.methods import media
 import smtplib
 from email.mime.text import MIMEText
 from email.mime.multipart import MIMEMultipart
-import math
 
 # Add enhanced CSS to block download buttons in audio players
 st.markdown("""
@@ -397,7 +396,7 @@ def show_sidebar():
                     # Format for premium users - CORRECTED LIMITS PER TIER
                     daily_limit = 0
                     download_limit = 0
-                    duration_limit = 300
+                    duration_limit = 140
                     
                     plan_id = subscription_status.get('subscription_plan_id')
                     if isinstance(plan_id, int):
@@ -1328,258 +1327,7 @@ def load_and_play_generated_audio(response, genre=None, energy_level=None, tempo
         st.error(f"Failed to process generated audio: {e}")
         return None, None
 
-def generate_long_audio_chunked(genre, energy_level, tempo, description, total_duration):
-    """
-    Generate long audio by making multiple sequential API calls and stitching the results
-    with improved error handling and robustness for different audio formats
-    """
-    # Maximum duration for a single request that works reliably
-    max_chunk_duration = 120  # Based on your working threshold
-    
-    # Calculate how many chunks we need
-    num_chunks = math.ceil(total_duration / max_chunk_duration)
-    
-    # Prepare to collect audio pieces
-    audio_chunks = []
-    sample_rate = None
-    
-    # Process each chunk
-    overall_progress = st.progress(0)
-    status_text = st.empty()
-    
-    try:
-        for i in range(num_chunks):
-            # Calculate duration for this chunk
-            chunk_duration = min(max_chunk_duration, total_duration - (i * max_chunk_duration))
-            
-            # Update the description for continuity
-            chunk_description = description
-            if i > 0:
-                chunk_description += f" (continuation part {i+1})"
-                
-            # Update status
-            status_text.markdown(f"🎵 **Generating part {i+1} of {num_chunks}** ({chunk_duration}s)...")
-            
-            # Prepare and send the request
-            prompt = f"Genre: {genre}, Energy Level: {energy_level}, Tempo: {tempo}, Description: {chunk_description}"
-            payload = {"inputs": {"prompt": prompt, "duration": chunk_duration}}
-            api_headers = get_api_headers()
-            
-            # Make the request with appropriate timeout
-            response = time_post_request(
-                API_URL, 
-                headers=api_headers, 
-                payload=payload, 
-                timeout=1200  # Match the endpoint timeout
-            )
-            
-            if not response or response.status_code != 200:
-                error_code = response.status_code if response else "No response"
-                status_text.error(f"❌ Error generating part {i+1}: HTTP {error_code}")
-                return None, None
-                
-            # Parse the response
-            try:
-                response_data = json.loads(response.content)
-                
-                # Check for error in response
-                if isinstance(response_data, dict) and 'error' in response_data:
-                    status_text.error(f"❌ API error in part {i+1}: {response_data['error']}")
-                    return None, None
-                
-                # Extract audio data from first item in the list
-                if isinstance(response_data, list) and len(response_data) > 0:
-                    chunk_data = response_data[0]
-                    
-                    # Extract audio data
-                    if "generated_audio" in chunk_data:
-                        chunk_audio = np.array(chunk_data["generated_audio"])
-                        
-                        # Log shape for debugging
-                        print(f"Chunk {i+1} audio shape: {chunk_audio.shape}")
-                        
-                        # Check for inconsistent shapes
-                        if len(audio_chunks) > 0:
-                            existing_shape = audio_chunks[0].shape
-                            if len(existing_shape) != len(chunk_audio.shape):
-                                print(f"WARNING: Shape mismatch between chunks. Existing: {existing_shape}, New: {chunk_audio.shape}")
-                        
-                        # Store sample rate from first chunk
-                        if sample_rate is None and "sample_rate" in chunk_data:
-                            sample_rate = chunk_data["sample_rate"]
-                            print(f"Using sample rate: {sample_rate}")
-                        
-                        # Add to our collection
-                        audio_chunks.append(chunk_audio)
-                    else:
-                        raise ValueError(f"No 'generated_audio' found in chunk {i+1}")
-                else:
-                    raise ValueError(f"Unexpected response format for chunk {i+1}")
-                
-                # Update progress
-                overall_progress.progress((i + 1) / num_chunks)
-                
-            except Exception as e:
-                import traceback
-                print(f"Error processing chunk {i+1}:")
-                print(traceback.format_exc())
-                status_text.error(f"❌ Error processing response for part {i+1}: {str(e)}")
-                return None, None
-        
-        # Handle the case when we couldn't get any valid chunks
-        if not audio_chunks:
-            status_text.error("❌ No valid audio chunks were generated.")
-            return None, None
-            
-        # Check if we at least have a sample rate
-        if sample_rate is None:
-            sample_rate = 44100  # Default to standard sample rate if not provided
-            print("WARNING: No sample rate provided, using default 44100 Hz")
-        
-        # Combine audio chunks with crossfading
-        status_text.markdown("🔄 Stitching audio chunks together...")
-        try:
-            # First check if we only have one chunk (no stitching needed)
-            if len(audio_chunks) == 1:
-                final_audio = audio_chunks[0]
-            else:
-                final_audio = combine_audio_with_crossfade(audio_chunks, sample_rate)
-            
-            # Final check for valid audio
-            if final_audio is None or final_audio.size == 0:
-                status_text.error("❌ Failed to create valid audio output.")
-                return None, None
-                
-            status_text.success("✅ Full audio track generated successfully!")
-            overall_progress.progress(1.0)
-            
-            return final_audio, sample_rate
-            
-        except Exception as e:
-            import traceback
-            print(f"Error combining audio chunks:")
-            print(traceback.format_exc())
-            status_text.error(f"❌ Error combining audio chunks: {str(e)}")
-            return None, None
-        
-    except Exception as e:
-        import traceback
-        print(f"Unexpected error in generation process:")
-        print(traceback.format_exc())
-        status_text.error(f"❌ Unexpected error in generation process: {str(e)}")
-        return None, None
 
-
-def combine_audio_with_crossfade(audio_chunks, sample_rate, crossfade_duration=2.0):
-    """
-    Combine multiple audio chunks with crossfading between them with improved
-    robustness for handling different array shapes and potential edge cases.
-    
-    Parameters:
-    audio_chunks: List of numpy arrays containing audio data
-    sample_rate: Sample rate of the audio
-    crossfade_duration: Crossfade duration in seconds
-    
-    Returns:
-    numpy.ndarray: Combined audio with crossfading
-    """
-    if not audio_chunks:
-        return None
-        
-    if len(audio_chunks) == 1:
-        return audio_chunks[0]
-    
-    # Print debugging info about chunks
-    print(f"Combining {len(audio_chunks)} audio chunks")
-    for i, chunk in enumerate(audio_chunks):
-        print(f"Chunk {i} shape: {chunk.shape}")
-    
-    # Calculate crossfade samples
-    crossfade_samples = int(crossfade_duration * sample_rate)
-    print(f"Crossfade samples: {crossfade_samples}")
-    
-    # Function to ensure consistent array dimensions
-    def normalize_audio_shape(audio):
-        """Make sure audio is 2D with shape (channels, samples)"""
-        if audio is None or audio.size == 0:
-            return np.zeros((1, 0))  # Return empty mono audio
-            
-        # Convert to 2D if needed
-        if audio.ndim == 1:
-            return audio.reshape(1, -1)  # Convert mono to shape (1, samples)
-        elif audio.ndim == 2:
-            # If shape is (samples, channels), transpose to (channels, samples)
-            if audio.shape[0] > 2 and (audio.shape[1] == 1 or audio.shape[1] == 2):
-                return audio.T
-            return audio
-        else:
-            # Unexpected shape - flatten to mono
-            print(f"WARNING: Unexpected audio shape {audio.shape}, flattening to mono")
-            flattened = audio.flatten()
-            return flattened.reshape(1, -1)
-    
-    # Normalize all chunks to ensure consistent shapes
-    normalized_chunks = [normalize_audio_shape(chunk) for chunk in audio_chunks]
-    
-    # Initialize with first chunk
-    combined_audio = normalized_chunks[0]
-    
-    # Add each subsequent chunk with crossfading
-    for i, next_chunk in enumerate(normalized_chunks[1:], 1):
-        print(f"Combining chunk {i} with combined audio")
-        print(f"Combined audio shape: {combined_audio.shape}, next chunk shape: {next_chunk.shape}")
-        
-        # Ensure both audio chunks have the same number of channels
-        if combined_audio.shape[0] != next_chunk.shape[0]:
-            # Handle different channel counts by converting to mono if needed
-            channels_to_use = min(combined_audio.shape[0], next_chunk.shape[0])
-            if channels_to_use == 1:
-                # Convert both to mono
-                if combined_audio.shape[0] > 1:
-                    combined_audio = np.mean(combined_audio, axis=0, keepdims=True)
-                if next_chunk.shape[0] > 1:
-                    next_chunk = np.mean(next_chunk, axis=0, keepdims=True)
-            else:
-                # Use only the first channel from each
-                combined_audio = combined_audio[:channels_to_use]
-                next_chunk = next_chunk[:channels_to_use]
-        
-        # Check if we have enough samples for crossfading
-        if (combined_audio.shape[1] >= crossfade_samples and 
-            next_chunk.shape[1] >= crossfade_samples):
-            
-            # Create fade curves
-            fade_out = np.linspace(1, 0, crossfade_samples)
-            fade_in = np.linspace(0, 1, crossfade_samples)
-            
-            # Create temporary copies to avoid modifying originals
-            combined_end = combined_audio[:, -crossfade_samples:].copy()
-            next_start = next_chunk[:, :crossfade_samples].copy()
-            
-            # Apply crossfade
-            for channel in range(combined_audio.shape[0]):
-                combined_end[channel] *= fade_out
-                next_start[channel] *= fade_in
-            
-            # Overlap and add
-            overlap_region = combined_end + next_start
-            
-            # Concatenate
-            combined_audio = np.concatenate([
-                combined_audio[:, :-crossfade_samples], 
-                overlap_region, 
-                next_chunk[:, crossfade_samples:]
-            ], axis=1)
-        else:
-            # Not enough samples for crossfade, just concatenate
-            print("WARNING: Not enough samples for crossfade, simple concatenation used")
-            combined_audio = np.concatenate([combined_audio, next_chunk], axis=1)
-    
-    print(f"Final combined audio shape: {combined_audio.shape}")
-    return combined_audio
-
-
-# Modify your existing generate_audio function to use chunking for long durations
 def generate_audio(genre, energy_level, tempo, description, duration):
     # Create placeholders
     status_placeholder = st.empty()
@@ -1620,7 +1368,12 @@ def generate_audio(genre, energy_level, tempo, description, duration):
         if is_free_tier:
             if duration > 30:
                 st.warning("⚠️ Free tier users are limited to 30-second generations.")
-                st.info("💡 Upgrade to a premium plan to generate longer tracks!")
+                st.info("💡 Upgrade to a premium plan to generate longer tracks!\n\n" + 
+                       "**Available Plans:**\n" +
+                       "- **$24.99/month:** Up to 3 generations per day, 1 download per month\n" +
+                       "- **$99.99/month:** Up to 5 generations per day, 5 downloads per month\n" +
+                       "- **$269.97/month:** Up to 20 generations per day, 15 downloads per month\n\n" +
+                       "👉 [Upgrade Now](https://songlabai.com/subscribe/)")
                 duration = 30  # Force duration to 30 seconds for free tier
                 
         # Check if server is cold
@@ -1629,7 +1382,8 @@ def generate_audio(genre, energy_level, tempo, description, duration):
                 "🔄 **Server is currently starting up.**\n\n"
                 "Our AI model needs some time to load and prepare when the server has been inactive.\n"
                 "This can take up to **7 minutes** for free users.\n\n"
-                "💡 **Upgrade to a premium plan to reduce or eliminate wait times!**"
+                "💡 **Upgrade to a premium plan to reduce or eliminate wait times!**\n"
+                "👉 [Upgrade Now](https://songlabai.com/subscribe/)"
             )
                 
             # Wait for server to warm up with progress display
@@ -1643,154 +1397,78 @@ def generate_audio(genre, energy_level, tempo, description, duration):
             if not server_ready:
                 st.error(
                     "❌ Server initialization timed out.\n\n"
-                    "Consider upgrading to premium for reliable, fast access."
+                    "Consider upgrading to premium for reliable, fast access.\n\n"
+                    "👉 [Upgrade Now](https://songlabai.com/subscribe/)"
                 )
                 return None
                     
         # Clear warmup messages
         for placeholder in [status_placeholder, progress_placeholder, subscription_placeholder, stage_placeholder]:
             placeholder.empty()
-        
-        # IMPORTANT: Choose between normal and chunked generation based on duration
-        if duration <= 120:  # For shorter durations that work reliably
-            # Prepare standard generation request
-            prompt = f"Genre: {genre}, Energy Level: {energy_level}, Tempo: {tempo}, Description: {description}"
-            payload = {"inputs": {"prompt": prompt, "duration": duration}}
-            api_headers = get_api_headers()
-            
-            # Make the generation request
-            with st.spinner("🎵 Generating your music... This may take a few moments."):
-                response = time_post_request(API_URL, headers=api_headers, payload=payload, timeout=1200)
                 
-                if response and response.status_code == 200:
-                    # Check for error in response before showing success message
-                    try:
-                        response_data = json.loads(response.content)
-                        if 'error' in response_data:
-                            error_msg = response_data['error']
-                            if 'CUDA error' in error_msg:
-                                st.error("❌ The AI server is currently experiencing GPU resource issues.")
-                                st.info("Please try again in a few minutes. This is a temporary server issue.")
-                                return None
-                            else:
-                                st.error(f"❌ Server error: {error_msg}")
-                                return None
-                        
-                        # If we get here, response is valid
-                        st.success("✨ Music generated successfully!")
-                    except Exception as parse_error:
-                        print(f"Error parsing response to check for errors: {parse_error}")
-                        st.success("✨ Music generated successfully!")
-                    
-                    # Load and play the generated audio
-                    result = load_and_play_generated_audio(
-                        response=response,
-                        genre=genre,
-                        energy_level=energy_level,
-                        tempo=tempo,
-                        description=description,
-                        duration=duration
-                    )
-                    
-                    # Only update count if audio was successfully generated
-                    if result[0] is not None:
-                        update_generation_url = "https://songlabai.com/wp-json/custom-api/v1/update-generation-count"
-                        requests.post(update_generation_url, headers=auth_headers)
-                    
-                    return response  # Return the response for future use
-                else:
-                    error_code = response.status_code if response else "No response"
-                    st.error(f"❌ Failed to generate audio (Error {error_code}).")
-                    return None
+        # Prepare generation request
+        prompt = f"Genre: {genre}, Energy Level: {energy_level}, Tempo: {tempo}, Description: {description}"
+        payload = {"inputs": {"prompt": prompt, "duration": duration}}
+        api_headers = get_api_headers()
         
-        else:
-            # For longer durations, use the chunked approach
-            st.info("💡 Generating a longer track in multiple parts. This may take several minutes.")
-            
-            # Generate audio in chunks and stitch together
-            audio_array, sample_rate = generate_long_audio_chunked(
-                genre, energy_level, tempo, description, duration
-            )
+        # Make the generation request
+        with st.spinner("🎵 Generating your music... This may take a few moments."):
+            response = time_post_request(API_URL, headers=api_headers, payload=payload, timeout=1200)
             
-            if audio_array is not None and sample_rate is not None:
-                # Convert the audio to a format that can be played
-                with st.spinner("🔄 Processing final audio..."):
-                    # Convert numpy array to bytes with careful handling of array shape
-                    audio_buffer = BytesIO()
-                    
-                    # The critical fix: transpose the array if needed
-                    # SoundFile expects shape (samples, channels) but our array is (channels, samples)
-                    if audio_array.ndim == 2 and audio_array.shape[0] <= 2:
-                        # This is the key fix - transpose from (channels, samples) to (samples, channels)
-                        print(f"Transposing audio array from shape {audio_array.shape}")
-                        audio_array_to_save = audio_array.T
-                    else:
-                        audio_array_to_save = audio_array
-                    
-                    # Ensure it's the right data type
-                    if audio_array_to_save.dtype != np.float32:
-                        audio_array_to_save = audio_array_to_save.astype(np.float32)
-                    
-                    print(f"Writing audio with shape {audio_array_to_save.shape} to WAV file")
-                    sf.write(audio_buffer, audio_array_to_save, sample_rate, format='WAV', subtype='PCM_16')
-                    audio_buffer.seek(0)
-                    
-                    # Convert to AudioSegment for compatibility with your existing code
-                    try:
-                        audio_segment = AudioSegment.from_file(audio_buffer, format="wav")
-                    except Exception as e:
-                        print(f"Error converting to AudioSegment: {e}")
-                        # Alternative approach if the first method fails
-                        audio_buffer.seek(0)
-                        with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as temp_file:
-                            temp_filename = temp_file.name
-                            temp_file.write(audio_buffer.read())
-                        
-                        # Now load from the temporary file
-                        audio_segment = AudioSegment.from_file(temp_filename, format="wav")
-                        # Clean up temp file
-                        os.unlink(temp_filename)
-                    
-                    # Store in session state (matching your existing patterns)
-                    st_state.audio_pydub = audio_segment
-                    st_state.audio_sample_rate = sample_rate
-                    st_state.augmented_audio_pydub = audio_segment
-                    st_state.augmented_audio_sample_rate = sample_rate
-                    
-                    # Set bytes for player
-                    audio_buffer.seek(0)
-                    st.session_state.audio_bytes = audio_buffer.getvalue()
-                    st.session_state.playing_state = 'generated'
+            if response and response.status_code == 200:
+                # Check for error in response before showing success message
+                try:
+                    response_data = json.loads(response.content)
+                    if 'error' in response_data:
+                        error_msg = response_data['error']
+                        if 'CUDA error' in error_msg:
+                            st.error("❌ The AI server is currently experiencing GPU resource issues.")
+                            st.info("Please try again in a few minutes. This is a temporary server issue.")
+                            print(f"CUDA error from server: {error_msg}")
+                            return None
+                        else:
+                            st.error(f"❌ Server error: {error_msg}")
+                            return None
                     
-                    # Store metadata
-                    st.session_state.audio_metadata = {
-                        'genre': genre,
-                        'energy_level': energy_level,
-                        'tempo': tempo,
-                        'description': description,
-                        'duration': duration,
-                        'generated_time': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
-                    }
+                    # If we get here, response is valid
+                    st.success("✨ Music generated successfully!")
+                except Exception as parse_error:
+                    print(f"Error parsing response to check for errors: {parse_error}")
+                    # Continue with normal flow - will be caught in load_and_play if there's an issue
+                    st.success("✨ Music generated successfully!")
                 
-                # Display the audio
-                st.success("✨ Long music track generated successfully!")
-                display_audio_player(is_final=False)
+                # Load and play the generated audio
+                result = load_and_play_generated_audio(
+                    response=response,
+                    genre=genre,
+                    energy_level=energy_level,
+                    tempo=tempo,
+                    description=description,
+                    duration=duration
+                )
                 
-                # Update generation count on WordPress
-                update_generation_url = "https://songlabai.com/wp-json/custom-api/v1/update-generation-count"
-                requests.post(update_generation_url, headers=auth_headers)
+                # Only update count if audio was successfully generated
+                if result[0] is not None:
+                    # Update generation count on WordPress
+                    update_generation_url = "https://songlabai.com/wp-json/custom-api/v1/update-generation-count"
+                    requests.post(update_generation_url, headers=auth_headers)
                 
-                return True
+                return response  # Return the response for future use
             else:
-                st.error("❌ Failed to generate the complete audio track.")
+                error_code = response.status_code if response else "No response"
+                st.error(
+                    f"❌ Failed to generate audio (Error {error_code}).\n\n"
+                    "This might be due to high server load or an error.\n\n"
+                    "💡 **Tip:** Premium users experience fewer failures and faster generation times.\n\n"
+                    "👉 [Upgrade Now](https://songlabai.com/subscribe/)"
+                )
                 return None
-                
     except Exception as e:
         import traceback
         print(f"Detailed error in generate_audio: {traceback.format_exc()}")
         st.error(f"An unexpected error occurred: {e}")
         return None
-        
+
 def update_generate_button(genre, energy_level, tempo, description, duration):
     """Create or update the generate button based on current state"""
     generate_btn_col, login_prompt_col = st.columns([1, 2])
@@ -1934,7 +1612,7 @@ with duration_col:
         duration = st.slider(
             "Duration (in seconds):",
             min_value=15,
-            max_value=300,
+            max_value=140,
             value=30,
             step=1
         )