Update app.py

app.py

@@ -3,12 +3,15 @@ import pandas as pd
 import time
 import gspread
 from google.oauth2.service_account import Credentials
+from datetime import datetime, timedelta
+import pytz
 
 # Global variable to control process interruption
 stop_flag = False
 
 # Authenticate using the service account credentials
 def authenticate_google_sheets():
+    print("Authenticating with Google Sheets...")
     # Define the scope and authenticate the client
     scope = [
         "https://www.googleapis.com/auth/spreadsheets",  # Access Google Sheets
@@ -18,59 +21,116 @@ def authenticate_google_sheets():
     # Load the service account credentials from the JSON file
     creds = Credentials.from_service_account_file('credentials.json', scopes=scope)
     client = gspread.authorize(creds)
+    print("Authentication successful.")
     return client
 
-# Function to upload each row to Google Spreadsheet with a delay
-def upload_to_google_sheets(csv_file, spreadsheet_id, delay):
+# Main function to upload the Excel data to Google Sheets, respecting delay between rows
+def upload_to_google_sheets(excel_file, spreadsheet_id, delay):
     global stop_flag
     stop_flag = False  # Reset stop flag when process starts
     
     # Authenticate and open the Google Spreadsheet
-    client = authenticate_google_sheets()
-    sheet = client.open_by_key(spreadsheet_id).sheet1  # Open the first sheet
+    try:
+        client = authenticate_google_sheets()
+        sheet = client.open_by_key(spreadsheet_id).sheet1  # Open the first sheet
+        print(f"Connected to Google Sheet: {spreadsheet_id}")
+    except Exception as e:
+        print(f"Error connecting to Google Sheets: {e}")
+        return f"Error: {e}"
+
+    # Read the Excel file
+    try:
+        print("Reading the Excel file...")
+        df = pd.read_excel(excel_file.name)
+        print("Excel file content:")
+        print(df.head())  # Print the first few rows to verify content
+    except Exception as e:
+        print(f"Error reading the Excel file: {e}")
+        return f"Error: {e}"
     
-    # Read the CSV file
-    df = pd.read_csv(csv_file.name)
+    # Replace NaN and infinite values with None to make them JSON-compliant
+    df = df.replace([float('inf'), float('-inf')], None)  # Handle infinity values
+    df = df.where(pd.notnull(df), None)  # Replace NaN values with None
     
     # Iterate through each row of the DataFrame
     for index, row in df.iterrows():
         if stop_flag:
             return "Process interrupted by the user."
         
-        # Convert row to list and append it to Google Sheets
-        sheet.append_row(row.values.tolist())
+        try:
+            # Convert only the first two columns of the row to a list
+            row_data = row.iloc[:2].tolist()  # Get the first and second columns
+            print(f"Uploading row {index}: {row_data}")
+            
+            # Append the first two columns to Google Sheets
+            sheet.append_row(row_data)
+            print(f"Row {index} uploaded successfully.")
+            
+        except Exception as e:
+            # Print the problematic row and the error
+            print(f"Error processing row {index}: {row_data}")
+            print(f"Error message: {e}")
+            continue  # Skip the current row and continue with the next one
         
         # Wait for the specified delay before processing the next row
         time.sleep(delay)
 
-    return "CSV rows have been successfully uploaded to the Google Sheet."
+    return "Excel rows have been successfully uploaded to the Google Sheet."
 
 # Function to stop the process
 def stop_process():
     global stop_flag
     stop_flag = True
+    print("Stop process signal received.")
     return "Process will stop after the current row is uploaded."
 
+# Function to handle scheduling the upload process and respect both target time and delay per row
+def schedule_upload(excel_file, spreadsheet_id, delay, target_time):
+    # Convert the input time to a Pacific Time (PST/PDT) datetime object
+    pacific = pytz.timezone("America/Los_Angeles")
+    current_time = datetime.now(pacific)
+
+    # Parse the target time
+    target_time = pacific.localize(datetime.strptime(target_time, '%Y-%m-%d %H:%M:%S'))
+
+    # Calculate the time difference
+    time_difference = (target_time - current_time).total_seconds()
+
+    if time_difference > 0:
+        # Wait until the target time
+        print(f"Waiting {time_difference} seconds until the scheduled time...")
+        time.sleep(time_difference)
+    
+    # Once the time is reached, call the upload_to_google_sheets function
+    return upload_to_google_sheets(excel_file, spreadsheet_id, delay)
+
 # Gradio Interface
-def gradio_interface(csv_file, spreadsheet_id, delay):
-    return upload_to_google_sheets(csv_file, spreadsheet_id, int(delay))
+def gradio_interface(excel_file, spreadsheet_id, delay, target_time):
+    return schedule_upload(excel_file, spreadsheet_id, int(delay), target_time)
 
-# Create Gradio app with file upload, spreadsheet ID input, delay input, and stop button
-csv_file_input = gr.File(label="Upload CSV File")  # File upload input
-spreadsheet_id_input = gr.Textbox(label="Google Spreadsheet ID")  # Textbox for Spreadsheet ID
-delay_input = gr.Number(label="Delay between rows (in seconds)", value=300)  # Number input for delay (default: 300 seconds)
+# Use gr.Blocks to combine multiple components
+with gr.Blocks() as demo:
+    excel_file_input = gr.File(label="Upload Excel File")  # File upload input for Excel
+    spreadsheet_id_input = gr.Textbox(label="Google Spreadsheet ID")  # Textbox for Spreadsheet ID
+    delay_input = gr.Number(label="Delay between rows (in seconds)", value=300)  # Number input for delay (default: 300 seconds)
+    target_time_input = gr.Textbox(label="Enter time to start (Pacific Time, format: YYYY-MM-DD HH:MM:SS)", 
+                                   placeholder="2024-09-25 14:30:00")
 
-# Create the interface
-interface = gr.Interface(
-    fn=gradio_interface,
-    inputs=[csv_file_input, spreadsheet_id_input, delay_input],
-    outputs=gr.Textbox(label="Result"),
-    live=False  # Disable continuous updates
-)
+    # Create the interface for uploading the file
+    result_output = gr.Textbox(label="Result")
+    upload_button = gr.Button("Schedule Upload")
+    
+    # Add the stop button within the same context
+    stop_button = gr.Button("Stop Process")
+    stop_status_output = gr.Textbox(label="Status")
 
-# Add a stop button to interrupt the process
-stop_interface = gr.Interface(fn=stop_process, inputs=None, outputs=gr.Textbox(label="Status"))
+    # Bind the upload button to start the process
+    upload_button.click(fn=gradio_interface, 
+                        inputs=[excel_file_input, spreadsheet_id_input, delay_input, target_time_input], 
+                        outputs=result_output)
+    
+    # Bind the stop button to stop the process
+    stop_button.click(fn=stop_process, inputs=[], outputs=stop_status_output)
 
-# Launch both interfaces
-interface.launch()
-stop_interface.launch()
+# Launch the demo
+demo.launch()