Update app.py

app.py

@@ -23,20 +23,15 @@ from wordpress_xmlrpc import Client
 from wordpress_xmlrpc.compat import xmlrpc_client
 from wordpress_xmlrpc.methods import media
 
-# API URLs
-WP_LOGIN_URL = "https://songlabai.com/login"
-CURRENT_USER_ID_API = "https://songlabai.com/wp-json/custom-api/v1/current-user-id-session"
-SUBSCRIPTION_API_BASE = "https://songlabai.com/wp-json/custom-api/subscription/"
-UPDATE_LIMIT_API_BASE = "https://songlabai.com/wp-json/custom-api/update-limit/"
-HUGGING_FACE_API_URL = "https://api-inference.huggingface.co/models/YOUR_MODEL_NAME"
-
-# Try to get API_URL and BEARER_TOKEN from environment variables, if not found set to a default value
+
+# Try to get API_URL from environment variables, if not found set to a default value
 try:
     API_URL = os.environ["API_URL"]
 except KeyError:
     st.error("API_URL environment variable is not set.")
     st.stop()
 
+# Try to get the Bearer token from environment variables, if not found set to a default value
 try:
     BEARER_TOKEN = os.environ["BEARER_TOKEN"]
 except KeyError:
@@ -56,119 +51,13 @@ background-size: cover;
 '''
 st.markdown(page_bg_img, unsafe_allow_html=True)
 
-# Function to check if the user is logged in
-def check_user_logged_in():
-    try:
-        response = requests.get(CURRENT_USER_ID_API)
-        if response.status_code == 200:
-            user_data = response.json()
-            if 'user_id' in user_data and user_data['user_id'] is not None:
-                return user_data['user_id']
-        return None
-    except Exception as e:
-        st.error(f"Error checking login status: {e}")
-        return None
-
-# Function to show the login button with redirection
-def show_login_button():
-    login_html = f'''
-    <a href="{WP_LOGIN_URL}" target="_self">
-        <button style="background-color: #4CAF50; color: white; padding: 15px 32px; text-align: center; 
-                text-decoration: none; display: inline-block; font-size: 16px; margin: 4px 2px; cursor: pointer;">
-            Login
-        </button>
-    </a>
-    '''
-    st.markdown(login_html, unsafe_allow_html=True)
-
-# Function to check the user's subscription
-def check_user_subscription(user_id):
-    try:
-        subscription_url = f"{SUBSCRIPTION_API_BASE}{user_id}"
-        response = requests.get(subscription_url)
-        if response.status_code == 200:
-            return response.json()  # Return the subscription data
-        else:
-            st.error(f"Error fetching subscription data: {response.status_code}")
-            return None
-    except Exception as e:
-        st.error(f"Error checking subscription: {e}")
-        return None
-
-# Function to update the user's daily limit after generating music
-def update_daily_limit(user_id):
-    try:
-        update_url = f"{UPDATE_LIMIT_API_BASE}{user_id}"
-        response = requests.post(update_url)
-        if response.status_code == 200:
-            st.success("Daily limit updated successfully.")
-        else:
-            st.error(f"Error updating daily limit: {response.status_code}")
-    except Exception as e:
-        st.error(f"Error updating daily limit: {e}")
-
-# Function to handle generation logic based on the subscription
-def handle_generation_logic(subscription_data):
-    # Check if the user is on the Free plan (ID: 576)
-    if subscription_data["subscription_plan_id"] == "576":
-        if subscription_data["has_exceeded_daily_limit"]:
-            st.error("You have reached your daily generation limit for the Free plan.")
-            return False
-        else:
-            st.success("You can generate music. You haven't hit your daily limit yet.")
-            return True
-    else:
-        # For paid plans, allow unlimited generation
-        st.success("You are on a paid plan. You can generate unlimited music.")
-        return True
-
-# Function to generate music using Hugging Face API
-def generate_music_with_hugging_face(prompt, duration=30):
-    headers = {"Authorization": f"Bearer YOUR_HUGGING_FACE_TOKEN"}
-    payload = {
-        "inputs": prompt,
-        "parameters": {"duration": duration}  # Example of sending duration to the API
-    }
-
-    try:
-        response = requests.post(HUGGING_FACE_API_URL, headers=headers, json=payload)
-        if response.status_code == 200:
-            return response.content  # Assuming the response returns audio bytes or a URL
-        else:
-            st.error(f"Error generating music: {response.status_code}")
-            return None
-    except Exception as e:
-        st.error(f"Error generating music: {e}")
-        return None
-
-# Function to handle the entire music generation process
-def generate_music(user_id, genre, energy_level, tempo, description, duration=30):
-    prompt = f"Genre: {genre}, Energy Level: {energy_level}, Tempo: {tempo}, Description: {description}"
-
-    # Simulate music generation with Hugging Face
-    st.info(f"Generating music with prompt: {prompt}")
-    
-    # Call Hugging Face API to generate music
-    audio_data = generate_music_with_hugging_face(prompt, duration)
-
-    if audio_data:
-        st.success("✔️ Music has been generated!")
-        st.audio(audio_data)  # This assumes Hugging Face returns raw audio data
-
-        # If the user is on the free plan, update their daily limit
-        subscription_data = check_user_subscription(user_id)
-        if subscription_data and subscription_data["subscription_plan_id"] == "576":
-            update_daily_limit(user_id)
-    else:
-        st.error("Failed to generate music. Please try again.")
-
-# Function to save generated audio to WordPress and WooCommerce
 def save_to_wordpress(channel1, channel2, sample_rate):
 
     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"
@@ -176,39 +65,58 @@ 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,
                     consumer_secret=consumer_secret,
                     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": [
                             {
@@ -221,47 +129,35 @@ 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)
 
-# Main function for the app
-def main():
-    st.title("Songlab AI - Music Generation")
 
-    user_id = check_user_logged_in()
+headers = {
+    "Authorization": f"Bearer {BEARER_TOKEN}",
+    "Content-Type": "application/json",
+}
 
-    if user_id:
-        st.success(f"User is logged in with ID: {user_id}")
+# Streamlit app title
+st.title("Songlab AI")
 
-        # Check the user's subscription
-        subscription_data = check_user_subscription(user_id)
-        
-        if subscription_data:
-            if subscription_data["status"] == "active":
-                # Handle the subscription-based generation logic
-                if handle_generation_logic(subscription_data):
-                    # User inputs for music generation
-                    genre = st.selectbox("Select Genre:", ["Pop", "Rock", "Jazz", "Hip Hop", "Classical"])
-                    energy_level = st.radio("Energy Level:", ["Low", "Medium", "High"])
-                    description = st.text_input("Description of the mood or theme:", "")
-                    tempo = st.slider("Tempo (in bpm):", min_value=60, max_value=180, value=100)
-                    duration = st.slider("Duration (in seconds):", min_value=15, max_value=300, value=30)
-
-                    if st.button("Generate Music"):
-                        generate_music(user_id, genre, energy_level, tempo, description, duration)
-            else:
-                st.error("Your subscription is not active. Please renew your subscription.")
-        else:
-            st.error("Unable to fetch subscription data.")
-    else:
-        st.warning("You are not logged in.")
-        show_login_button()
-        
 # Initialize session state variables
 if "vocal_audio" not in st_state:
     st_state.vocal_audio = None
@@ -281,6 +177,195 @@ 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()
+
+    execution_time = end_time - start_time
+    print(f"Execution time: {execution_time} seconds")
+
+    return response
+
+def generate_audio(genre, energy_level, tempo, description, 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)
+            if response.status_code != 200:
+                placeholder1.error(
+                    "Failed to generate audio after multiple attempts. Please try again later."
+                )
+            else:
+                placeholder1.success(f"✔️ Audio Generated, Loading...")
+                load_and_play_generated_audio(response)
+                placeholder1.empty()
+        else:
+            placeholder1.success(f"✔️ Audio Generated, Loading...")
+            load_and_play_generated_audio(response)
+            placeholder1.empty()
+    else:
+        placeholder1.success(f"✔️ Audio Generated, Loading...")
+        load_and_play_generated_audio(response)
+        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]
+    with NamedTemporaryFile() as f1:
+        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)
+            )
+            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)
+    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])
+    
+    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, please contact the admin by sending the following link: {perm_link}"
+        )
+        st.write(f"To download use the following product code: {product_code}")
+
+
+if st.button("Generate Audio"):
+    if genre and energy_level and description and tempo:
+        generate_audio(genre, energy_level, tempo, description, duration)
+        
+    if description == "":
+        st.info("Description field is required.")
+
 # Post-processing options
 st.header("Post-processing Options")