Update app.py

app.py

@@ -6,6 +6,7 @@ import uuid
 from datetime import datetime
 from io import BytesIO
 from tempfile import NamedTemporaryFile
+from xmlrpc.client import Binary
 import jwt
 
 import numpy as np
@@ -50,40 +51,13 @@ background-size: cover;
 '''
 st.markdown(page_bg_img, unsafe_allow_html=True)
 
-# Helper functions
-def check_user_login():
-    """Check if the user is logged in by calling the WordPress API"""
-    api_url = "https://songlabai.com/wp-json/custom-api/v1/current-user-id-session"
-    response = requests.get(api_url)
-    if response.status_code == 200:
-        user_data = response.json()
-        if 'user_id' in user_data:
-            return user_data['user_id']
-    return None
-
-def get_user_subscription(user_id):
-    """Retrieve the subscription status and daily limit information"""
-    api_url = f"https://songlabai.com/wp-json/custom-api/subscription/{user_id}"
-    response = requests.get(api_url)
-    if response.status_code == 200:
-        return response.json()
-    return None
-
-def update_user_generation_limit(user_id):
-    """Update the user's daily generation limit once successful generation occurs"""
-    api_url = f"https://songlabai.com/wp-json/custom-api/update-limit/{user_id}"
-    response = requests.post(api_url)
-    if response.status_code != 200:
-        print("Failed to update the user's daily limit.")
-    else:
-        print("User's daily limit updated successfully.")
-
 def save_to_wordpress(channel1, channel2, sample_rate):
-    """Save generated audio to WordPress and WooCommerce"""
+
     channel1 = np.array(channel1).astype(np.float32)
     channel2 = np.array(channel2).astype(np.float32)
     stereo_audio = np.column_stack((channel1, channel2))
 
+    # Define your WordPress site URL and authentication credentials
     wordpress_url = "https://songlabai.com/xmlrpc.php"
     woocommerce_url = "https://songlabai.com"
     consumer_key = "ck_93d516ba12289a6fd0eced56bbc0b05ecbf98735"
@@ -91,30 +65,42 @@ def save_to_wordpress(channel1, channel2, sample_rate):
     username = "admin_h2ibbgql"
     password = "um^VdaNK0H8Vw2*KNJlYABkh"
 
+    # Authenticate with WordPress XML-RPC API
     wav_bytes = BytesIO()
     sf.write(wav_bytes, stereo_audio, samplerate=sample_rate, format="WAV")
     title = f"generated_audio_{datetime.now().timestamp()}.wav"
     file_data = {
         "name": title,
-        "type": "audio/x-wav",
+        "type": "audio/x-wav",  # Change the MIME type according to your file type
         "bits": xmlrpc_client.Binary(wav_bytes.getvalue()),
     }
     wp_client = Client(wordpress_url, username, password)
     for _ in range(4):
         try:
+            # Upload the file to WordPress Media Library
+
             media_response = wp_client.call(media.UploadFile(file_data))
+
+            # Handle the response
             if media_response:
+                print(
+                    "File successfully uploaded to WordPress with attachment ID:",
+                    media_response,
+                )
+
+                # Create product data for WooCommerce
                 product_data = {
                     "status": "pending",
                     "name": title,
                     "type": "simple",
-                    "regular_price": "1.00",
+                    "regular_price": "1.00",  # Set the price as needed
                     "sku": str(uuid.uuid4()),
                     "downloadable": True,
                     "download_limit": -1,
                     "download_expiry": -1,
                 }
 
+                # Authenticate with WooCommerce API
                 wc_api = API(
                     url=woocommerce_url,
                     consumer_key=consumer_key,
@@ -122,8 +108,15 @@ def save_to_wordpress(channel1, channel2, sample_rate):
                     version="wc/v3",
                 )
 
+                # Create the product
                 response = wc_api.post("products", product_data)
+
+                # Handle the response
                 if response.status_code == 201:
+                    print(
+                        "Product successfully created in WooCommerce:", response.json()
+                    )
+                    # Update product to add downloadable file URL
                     product_update_data = {
                         "downloads": [
                             {
@@ -136,115 +129,243 @@ def save_to_wordpress(channel1, channel2, sample_rate):
                     response = wc_api.put(f"products/{product_id}", product_update_data)
 
                     if response.status_code == 200:
+                        print(
+                            "Downloadable file URL added to product:", response.json()
+                        )
                         return (
                             response.json()["permalink"],
                             response.json()["permalink"].split("p=")[-1],
                         )
+                    else:
+                        print(
+                            "Error adding downloadable file URL to product:",
+                            response.text,
+                        )
+                else:
+                    print("Error creating product in WooCommerce:", response.text)
+            else:
+                print("Error uploading file to WordPress.")
             break
         except Exception as e:
             print("Error:", e)
 
 
+headers = {
+    "Authorization": f"Bearer {BEARER_TOKEN}",
+    "Content-Type": "application/json",
+}
+
+# Streamlit app title
+st.title("Songlab AI")
+
+# Initialize session state variables
+if "vocal_audio" not in st_state:
+    st_state.vocal_audio = None
+if "vocal_sample_rate" not in st_state:
+    st_state.vocal_sample_rate = None
+
+if "audio" not in st_state:
+    st_state.audio = None
+if "audio_pydub" not in st_state:
+    st_state.audio_pydub = None
+if "audio_sample_rate" not in st_state:
+    st_state.audio_sample_rate = None
+
+if "augmented_audio" not in st_state:
+    st_state.augmented_audio = None
+if "augmented_audio_pydub" not in st_state:
+    st_state.augmented_audio_pydub = None
+if "augmented_audio_sample_rate" not in st_state:
+    st_state.augmented_audio_sample_rate = None
+
+
+genres = [
+    "Pop",
+    "Rock",
+    "Hip Hop",
+    "Jazz",
+    "Blues",
+    "Country",
+    "Classical",
+    "Electronic",
+    "Reggae",
+    "Folk",
+    "R&B",
+    "Metal",
+    "Punk",
+    "Indie",
+    "Dance",
+    "World",
+    "Gospel",
+    "Soul",
+    "Funk",
+    "Ambient",
+    "Techno",
+    "Disco",
+    "House",
+    "Trance",
+    "Dubstep",
+]
+
+genre = st.selectbox("Select Genre:", genres)
+energy_levels = ["Low", "Medium", "High"]
+energy_level = st.radio("Energy Level:", energy_levels, horizontal=True)
+description = st.text_input("Description:", "")
+tempo = st.slider("Tempo (in bpm):", min_value=40, max_value=100, value=60, step=5)
+
+# Duration input
+duration = st.slider(
+    "Duration (in seconds):", min_value=15, max_value=300, value=30, step=1
+)
+
+prompt2 = "Classical ,Low, 40, slow calm"
+
+
+def convert_audio_segment_to_float_array(audio_pydub):
+    """
+    Convert a pydub AudioSegment to a NumPy array of type float32.
+
+    Args:
+    audio_pydub (AudioSegment): The AudioSegment object to be converted.
+
+    Returns:
+    np.ndarray: A NumPy array containing the audio data as float32.
+    """
+    # Get the raw audio data as a sequence of samples
+    samples = audio_pydub.get_array_of_samples()
+
+    # Convert the samples to a NumPy array and normalize to float32
+    audio_array = np.array(samples).astype(np.float32)
+
+    # Normalize the audio array to range between -1.0 and 1.0
+    max_val = 2**15  # Assuming 16-bit audio, modify this if using different bit depths
+    audio_array /= max_val
+    return audio_array
+
 def time_post_request(api_url, headers=None, payload=None):
+    """
+    Times the execution of a POST request.
+
+    Parameters:
+    - api_url (str): The URL to which the POST request is sent.
+    - headers (dict): The headers to include in the POST request.
+    - payload (dict): The payload to include in the POST request.
+
+    Returns:
+    - response (requests.Response): The response object returned by the POST request.
+    - execution_time (float): The time it took to execute the POST request.
+    """
     start_time = time.time()
     response = requests.post(api_url, headers=headers, json=payload)
     end_time = time.time()
-    print(f"Execution time: {end_time - start_time} seconds")
+
+    execution_time = end_time - start_time
+    print(f"Execution time: {execution_time} seconds")
+
     return response
 
 def generate_audio(genre, energy_level, tempo, description, duration):
-    user_id = check_user_login()
-    if user_id:
-        subscription_info = get_user_subscription(user_id)
-        if subscription_info:
-            plan_id = subscription_info['subscription_plan_id']
-            has_exceeded_daily_limit = subscription_info['has_exceeded_daily_limit']
-            
-            if plan_id == "576" and has_exceeded_daily_limit:
-                st.warning("You've reached your daily limit for free users. Upgrade to a paid plan to generate more audio.")
-                st.stop()
-
-            count_down = 300
-            prompt = f"Genre: {genre}, Energy Level: {energy_level}, Tempo: {tempo}, Description: {description},"
-            payload = {"inputs": {"prompt": prompt, "duration": duration}}
+    count_down = 300
+    prompt = f"Genre: {genre}, Energy Level: {energy_level}, Tempo: {tempo}, Description: {description},"
+    payload = {"inputs": {"prompt": prompt, "duration": duration}}
+    with st.spinner("Generating audio ..."):
+        response = time_post_request(API_URL, headers, payload)
+    placeholder1 = st.empty()
+    if response.status_code != 200:
+        # Temp Jay Start
+        print(f"Request Headers: {response.request.headers}")
+        print(f"Request Body: {response.request.body}")
+        print(f"Response Code: {response.status_code}")
+        print(f"Response Body: {response.text}")
+        # Temp Jay End
+
+        
+        print(str(response.content))
+        count_down_placeholder = st.empty()
+        for seconds in range(count_down):
+            count_down_placeholder.info(
+                f"The server is currently loading. Retrying in ⏳ {count_down - seconds} seconds."
+            )
+            time.sleep(1)
+        count_down_placeholder.empty()
+        with st.spinner("Generating audio ..."):
+            response = time_post_request(API_URL, headers, payload)
+        if response.status_code != 200:
+            count_down_placeholder = st.empty()
+            for seconds in range(count_down):
+                count_down_placeholder.info(
+                    f"2nd attempt failed. trying again one more time in ⏳ {count_down - seconds} seconds."
+                )
+                time.sleep(1)
+            count_down_placeholder.empty()
             with st.spinner("Generating audio ..."):
                 response = time_post_request(API_URL, headers, payload)
-
-            placeholder1 = st.empty()
-            if response.status_code == 200:
-                placeholder1.success("✔️ Audio Generated, Loading...")
-                load_and_play_generated_audio(response)
-                update_user_generation_limit(user_id)  # Update daily limit after successful generation
+            if response.status_code != 200:
+                placeholder1.error(
+                    "Failed to generate audio after multiple attempts. Please try again later."
+                )
             else:
-                handle_failed_request(response, count_down, payload)
+                placeholder1.success(f"✔️ Audio Generated, Loading...")
+                load_and_play_generated_audio(response)
+                placeholder1.empty()
         else:
-            st.warning("Unable to retrieve subscription details.")
+            placeholder1.success(f"✔️ Audio Generated, Loading...")
+            load_and_play_generated_audio(response)
+            placeholder1.empty()
     else:
-        st.warning("You must be logged in to generate audio.")
-        st.button("Login", on_click=lambda: st.experimental_set_query_params(next="https://songlabai.com/login"))
-
-def handle_failed_request(response, count_down, payload):
-    print(f"Response Code: {response.status_code}")
-    print(f"Response Body: {response.text}")
-    count_down_placeholder = st.empty()
-    for seconds in range(count_down):
-        count_down_placeholder.info(f"Retrying in ⏳ {count_down - seconds} seconds.")
-        time.sleep(1)
-    count_down_placeholder.empty()
-    with st.spinner("Generating audio ..."):
-        response = time_post_request(API_URL, headers, payload)
-    if response.status_code == 200:
+        placeholder1.success(f"✔️ Audio Generated, Loading...")
         load_and_play_generated_audio(response)
-    else:
-        st.error("Failed to generate audio. Please try again later.")
+        placeholder1.empty()
+
 
 def load_and_play_generated_audio(response):
-    response_eval = json.loads(response.content)
-    channel1 = response_eval[0]["generated_audio"][0]
-    channel2 = response_eval[0]["generated_audio"][1]
     
+    response_eval = json.loads(response.content)
+    channel1 =  response_eval[0]["generated_audio"][0]
+    channel2 =  response_eval[0]["generated_audio"][1]
     with NamedTemporaryFile() as f1:
-        scipy.io.wavfile.write(f1.name, rate=32000, data=np.array(channel1).astype(np.float32))
+        scipy.io.wavfile.write(
+            f1.name, rate=32000, data=np.array(channel1).astype(np.float32)
+        )
         channel1_temp = AudioSegment.from_file(f1.name)
         with NamedTemporaryFile() as f2:
-            scipy.io.wavfile.write(f2.name, rate=32000, data=np.array(channel2).astype(np.float32))
+            scipy.io.wavfile.write(
+                f2.name, rate=32000, data=np.array(channel2).astype(np.float32)
+            )
             channel2_temp = AudioSegment.from_file(f2.name)
             audio_pydub = AudioSegment.from_mono_audiosegments(channel1_temp, channel2_temp)
             st_state.audio_pydub = audio_pydub
             st_state.audio_pydub_sample_rate = audio_pydub.frame_rate
-
+    
     st_state.audio = np.array(st_state.audio_pydub.get_array_of_samples()).astype(np.float32)
-    perm_link, product_code = save_to_wordpress(channel1, channel2, 32000)
-
+    sample_rate = response_eval[0]["sample_rate"]
+    perm_link, product_code = save_to_wordpress(
+        channel1, channel2, 32000
+    )
+    
+    st_state.audio_sample_rate = sample_rate
     st_state.augmented_audio_pydub = st_state.audio_pydub
     st.audio(st_state.audio_pydub.export().read())
-    col_btn, col_text = st.columns([2, 4])
+    col_btn, col_text = st.columns([2,4])
     
     with col_btn:
         st.link_button("Publish your Song", "https://songlabai.com/contact_us/")
         st.link_button("Download Song", "https://songlabai.com/download-music/")
         
     with col_text:
-        st.write(f"To publish, contact admin using this link: {perm_link}")
-        st.write(f"To download, use this product code: {product_code}")
-
+        st.write(
+            f"To Publish, please contact the admin by sending the following link: {perm_link}"
+        )
+        st.write(f"To download use the following product code: {product_code}")
 
-# Streamlit UI elements
-st.title("Songlab AI")
 
 if st.button("Generate Audio"):
-    genre = st.selectbox("Select Genre:", ["Pop", "Rock", "Hip Hop", "Jazz", "Classical"])
-    energy_level = st.radio("Energy Level:", ["Low", "Medium", "High"], horizontal=True)
-    description = st.text_input("Description:", "")
-    tempo = st.slider("Tempo (in bpm):", min_value=40, max_value=100, value=60, step=5)
-    duration = st.slider("Duration (in seconds):", min_value=15, max_value=300, value=30, step=1)
-
-    if description:
+    if genre and energy_level and description and tempo:
         generate_audio(genre, energy_level, tempo, description, duration)
-    else:
+        
+    if description == "":
         st.info("Description field is required.")
 
-
 # Post-processing options
 st.header("Post-processing Options")