Update app.py

app.py

@@ -1,336 +1,344 @@
-from fastapi import FastAPI, HTTPException
-from pydantic import BaseModel, validator
-import requests
-import uvicorn
-import firebase_admin
-from firebase_admin import credentials, firestore
-import logging
-from datetime import datetime
-import pytz
-import os
-from fastapi import APIRouter, HTTPException
-import requests
-
-app = APIRouter()
-# Set up logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-app = FastAPI()
-
-# Initialize Firebase Admin SDK
-try:
-    cred = credentials.Certificate("serviceAccountKey.json")
-    firebase_admin.initialize_app(cred)
-    db = firestore.client()
-except Exception as e:
-    logger.error(f"Failed to initialize Firebase Admin SDK: {str(e)}")
-    raise
-class UpdateStatusRequest(BaseModel):
-    userId: str
-    medicineName: str
-    medicineTime: str  # Expected format: "HH:MM"
-
-class Credentials(BaseModel):
-    esp32_ip: str
-    user: str  # Changed from email to user
-
-    @validator("esp32_ip")
-    def validate_esp32_ip(cls, value):
-        # Remove http:// or https:// if present
-        value = value.replace("http://", "").replace("https://", "")
-        # Check for invalid IP like 0.0.0.0
-        if "0.0.0.0" in value:
-            raise ValueError("Invalid ESP32 IP address: 0.0.0.0 is not a valid destination address")
-        return value
-
-def convert_to_serializable(obj):
-    """Convert Firestore timestamps and other non-serializable objects to JSON-serializable format."""
-    if isinstance(obj, firebase_admin.firestore.firestore.DocumentReference):
-        return str(obj.path)
-    if hasattr(obj, 'isoformat'):  # Handles DatetimeWithNanoseconds
-        return obj.isoformat()
-    if isinstance(obj, dict):
-        return {k: convert_to_serializable(v) for k, v in obj.items()}
-    if isinstance(obj, list):
-        return [convert_to_serializable(item) for item in obj]
-    return obj
-
-def convert_times_to_ist(medicine_times):
-    utc = pytz.utc
-    ist = pytz.timezone("Asia/Kolkata")
-    converted_times = []
-
-    for t in medicine_times:
-        try:
-            if isinstance(t, datetime):
-                utc_time = t.astimezone(utc)
-            elif isinstance(t, str):
-                if "Z" in t:
-                    utc_time = datetime.fromisoformat(t.replace("Z", "+00:00")).astimezone(utc)
-                else:
-                    utc_time = datetime.fromisoformat(t).astimezone(utc)
-            else:
-                logger.warning(f"[convert_times_to_ist] Unsupported type for medicineTime: {type(t)}")
-                continue
-
-            ist_time = utc_time.astimezone(ist)
-            converted_times.append(ist_time.strftime("%H:%M"))  # HH:MM format
-        except Exception as e:
-            logger.warning(f"[convert_times_to_ist] Error converting time '{t}': {e}")
-    return converted_times
-
-
-@app.post("/send_medicineData")
-async def send_medicineData(data: Credentials):
-    try:
-        logger.info(f"Received request: {data}")
-
-        # Step 1: Retrieve the medicines array from Firestore using user ID
-        logger.info(f"Fetching medicines data for user: {data.user}")
-        doc_ref = db.collection("users").document(data.user)
-        doc = doc_ref.get()
-
-        if not doc.exists:
-            logger.error("User data not found")
-            raise HTTPException(status_code=404, detail={"error": "User data not found"})
-
-        user_data = doc.to_dict()
-        medicines_data = user_data.get("medicines", [])  # Fetch medicines list safely
-
-        if not medicines_data:
-            logger.error("Medicines data not found for this user")
-            raise HTTPException(status_code=404, detail={"error": "Medicines data not found for this user"})
-
-        # Step 2: Extract and filter medicine details based on endDate
-        current_date = datetime.now(pytz.UTC)  # Current date in UTC
-        logger.info(f"Current date (UTC): {current_date}")
-        
-        extracted_medicines = []
-        for medicine in medicines_data:
-            end_date_raw = medicine.get("endDate")
-            if not end_date_raw:
-                logger.warning(f"Medicine missing endDate: {medicine}")
-                continue
-
-            try:
-                # Handle endDate (already converted to datetime by Firestore Admin SDK)
-                if isinstance(end_date_raw, datetime):
-                    end_date = end_date_raw
-                    if end_date.tzinfo is None:  # If no timezone info, assume UTC
-                        end_date = end_date.replace(tzinfo=pytz.UTC)
-                    else:
-                        end_date = end_date.astimezone(pytz.UTC)  # Convert to UTC for comparison
-                elif isinstance(end_date_raw, str):
-                    # Fallback for string format (e.g., "April 17, 2025 at 12:00:00 AM UTC+5:30")
-                    end_date_str = end_date_raw.replace("at ", "").replace("\u202f", " ")
-                    end_date = datetime.strptime(end_date_str, "%B %d, %Y %I:%M:%S %p UTC%z")
-                    end_date = end_date.astimezone(pytz.UTC)  # Convert to UTC for comparison
-                else:
-                    logger.warning(f"Unsupported endDate type: {type(end_date_raw)}, value: {end_date_raw}")
-                    continue
-
-                # Only include medicines with endDate in the future
-                if end_date > current_date:
-                    extracted_medicines.append({
-                        "doseFrequency": medicine.get("doseFrequency"),
-                        "endDate": medicine.get("endDate"),
-                        "medicineNames": medicine.get("medicineNames", []),
-                        "medicineTimes": convert_times_to_ist(medicine.get("medicineTimes", {})),
-                        "selectedDays": medicine.get("selectedDays", [])
-                    })
-                    
-                else:
-                    logger.info(f"Skipping medicine with expired endDate: {end_date_raw}")
-
-            except ValueError as e:
-                logger.warning(f"Failed to parse endDate: {end_date_raw}, error: {str(e)}")
-                continue
-
-        # Step 3: Check if there are any valid medicines to send
-        if not extracted_medicines:
-            logger.info("No medicines with endDate in the future found.")
-            return {
-                "message": "No medicines with endDate in the future found.",
-                "medicines": []
-            }
-
-        # Convert any non-serializable objects (e.g., timestamps)
-        extracted_medicines = convert_to_serializable(extracted_medicines)
-
-        # Step 4: Send the medicines data to ESP32
-        esp32_ip = data.esp32_ip.replace("http://", "").replace("https://", "")
-        esp32_url = f"http://{esp32_ip}/credentials"
-        logger.info(f"Sending medicines data to ESP32 at {esp32_url}")
-        esp32_response = requests.post(esp32_url, json={"medicines": extracted_medicines}, timeout=20)
-        esp32_response.raise_for_status()
-
-        logger.info("Medicines data sent successfully")
-        return {
-            "message": "Medicines data sent successfully",
-            "medicines": [
-                {
-                    "medicineNames": med.get("medicineNames", []),
-                    "medicineTimes": med.get("medicineTimes", [])
-                }
-                for med in extracted_medicines
-            ],
-            "esp32_response": esp32_response.text
-        }
-
-    except requests.exceptions.RequestException as e:
-        logger.error(f"Request error: {str(e)}")
-        raise HTTPException(status_code=500, detail={"error": f"Failed to connect to ESP32: {str(e)}"})
-    except HTTPException as e:
-        raise e
-    except Exception as e:
-        logger.error(f"Unexpected error: {str(e)}", exc_info=True)
-        raise HTTPException(status_code=500, detail={"error": f"Unexpected error: {str(e)}"})
-
-def send_command(data: Credentials, command: str):
-    try:
-        esp32_ip = data.esp32_ip.replace("http://", "").replace("https://", "")
-        url = f"http://{esp32_ip}/command/{command}"
-        logger.info(f"Sending command: {command} to {url}")
-        response = requests.get(url, timeout=10)
-        response.raise_for_status()
-        return {"message": f"{command.capitalize()} command sent successfully", "esp32_response": response.text}
-    except requests.exceptions.RequestException as e:
-        raise HTTPException(status_code=500, detail={"error": f"Failed to send {command} command: {str(e)}"})
-    
-
-
-def ping_device(ip: str) -> bool:
-    try:
-        # Run the ping command and capture the output
-        response = os.popen(f'ping {ip}').read()
-        
-        # Check if "Request timed out" or "Destination host unreachable" appears in the response
-        if "Request timed out" in response or "Destination host unreachable" in response:
-            return False
-        else:
-            return True
-    except Exception as e:
-        print(f"Error while pinging: {e}")
-        return False
-
-# Endpoint to check the microcontroller's availability
-@app.post("/command/microcontroller")
-def check_microcontroller(data: Credentials):
-    # First, check if the ESP32 is reachable using the ping_device function
-    if not ping_device(data.esp32_ip):
-        return {"status": "error", "message": f"Microcontroller at {data.esp32_ip} is not reachable."}
-    
-    # If reachable, return a success message without sending any command to the ESP32
-    return {"status": "success", "message": f"Microcontroller at {data.esp32_ip} is reachable."}
-
-
-@app.post("/command/reset")
-def reset_device(data: Credentials):
-    return send_command(data, "reset")
-
-@app.post("/command/camera")
-def check_camera(data: Credentials):
-    return send_command(data, "camera")
-
-@app.post("/command/lcd")
-def check_lcd(data: Credentials):
-    return send_command(data, "lcd")
-
-@app.post("/command/motor")
-def check_motor(data: Credentials):
-    return send_command(data, "motor")
-
-@app.post("/command/battery")
-def check_battery(data: Credentials):
-    return send_command(data, "battery")
-
-@app.post("/update_medicine_status")
-def update_medicine_status(req: UpdateStatusRequest):
-    try:
-        current_date = datetime.now().strftime('%d-%m-%Y')
-        print(f"[INFO] Processing for user={req.userId}, medicine={req.medicineName}, time={req.medicineTime}")
-
-        user_ref = db.collection("users").document(req.userId)
-        user_doc = user_ref.get()
-
-        if not user_doc.exists:
-            raise HTTPException(status_code=404, detail="User not found")
-
-        user_data = user_doc.to_dict()
-        medicines = user_data.get("medicines", [])
-
-        print(f"[DEBUG] Total medicine entries: {len(medicines)}")
-
-        # First, find all matches by name
-        matched_indices = [
-            idx for idx, med in enumerate(medicines)
-            if req.medicineName in med.get("medicineNames", [])
-        ]
-
-        print(f"[DEBUG] Found {len(matched_indices)} medicine(s) with name match")
-
-        target_index = None
-
-        if len(matched_indices) == 1:
-            target_index = matched_indices[0]
-        else:
-            # Multiple matches, match by time
-            for idx in matched_indices:
-                for ts in medicines[idx].get("medicineTimes", []):
-                    try:
-                        if hasattr(ts, "strftime"):
-                            time_str = ts.strftime("%H:%M")
-                            print(f"[TRACE] Comparing time: {time_str} == {req.medicineTime}")
-                            if time_str == req.medicineTime:
-                                target_index = idx
-                                break
-                    except Exception as e:
-                        print(f"[ERROR] Timestamp parsing failed: {e}")
-                if target_index is not None:
-                    break
-
-        if target_index is None:
-            raise HTTPException(status_code=404, detail="Matching medicine name and time not found.")
-
-        # Update the status
-        print(f"[INFO] Updating index {target_index}")
-        if "status" not in medicines[target_index]:
-            medicines[target_index]["status"] = {}
-        medicines[target_index]["status"][current_date] = "taken"
-
-        # Push the full list back
-        user_ref.update({"medicines": medicines})
-        print(f"[SUCCESS] Updated medicine status at index {target_index}")
-
-        return {"message": f"Medicine status updated at index {target_index}"}
-
-    except Exception as e:
-        print(f"[ERROR] {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-    
-class BuzzerRequest(BaseModel):
-    esp32_ip: str
-    sound_type: str  # Options: relaxing, soft_melody, gentle_chime, calm_tune, beep_beep
-
-@app.post("/buzzer/play")
-def play_buzzer(data: BuzzerRequest):
-    valid_sounds = ["relaxing", "soft_melody", "gentle_chime", "calm_tune", "beep_beep"]
-
-    if data.sound_type not in valid_sounds:
-        raise HTTPException(status_code=400, detail="Invalid sound type selected.")
-
-    try:
-        url = f"http://{data.esp32_ip}/play_buzzer?sound={data.sound_type}"
-        response = requests.get(url, timeout=5)
-        response.raise_for_status()
-        return {
-            "status": "success",
-            "message": f"Playing {data.sound_type} on ESP32",
-            "esp32_response": response.text
-        }
-    except requests.RequestException as e:
-        raise HTTPException(status_code=500, detail=f"Failed to send buzzer command: {e}")
-
-if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=5000)
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel, validator
+import requests
+import uvicorn
+import firebase_admin
+from firebase_admin import credentials, firestore
+import logging
+from datetime import datetime
+import pytz
+import os
+from fastapi import APIRouter, HTTPException
+import requests
+
+router = APIRouter()
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI()
+
+@app.get("/", include_in_schema=False)
+async def _health_check():
+    return {"status": "healthy"}
+
+app.include_router(router)
+
+# Initialize Firebase Admin SDK
+try:
+    cred = credentials.Certificate("serviceAccountKey.json")
+    firebase_admin.initialize_app(cred)
+    db = firestore.client()
+except Exception as e:
+    logger.error(f"Failed to initialize Firebase Admin SDK: {str(e)}")
+    raise
+class UpdateStatusRequest(BaseModel):
+    userId: str
+    medicineName: str
+    medicineTime: str  # Expected format: "HH:MM"
+
+class Credentials(BaseModel):
+    esp32_ip: str
+    user: str  # Changed from email to user
+
+    @validator("esp32_ip")
+    def validate_esp32_ip(cls, value):
+        # Remove http:// or https:// if present
+        value = value.replace("http://", "").replace("https://", "")
+        # Check for invalid IP like 0.0.0.0
+        if "0.0.0.0" in value:
+            raise ValueError("Invalid ESP32 IP address: 0.0.0.0 is not a valid destination address")
+        return value
+
+def convert_to_serializable(obj):
+    """Convert Firestore timestamps and other non-serializable objects to JSON-serializable format."""
+    if isinstance(obj, firebase_admin.firestore.firestore.DocumentReference):
+        return str(obj.path)
+    if hasattr(obj, 'isoformat'):  # Handles DatetimeWithNanoseconds
+        return obj.isoformat()
+    if isinstance(obj, dict):
+        return {k: convert_to_serializable(v) for k, v in obj.items()}
+    if isinstance(obj, list):
+        return [convert_to_serializable(item) for item in obj]
+    return obj
+
+def convert_times_to_ist(medicine_times):
+    utc = pytz.utc
+    ist = pytz.timezone("Asia/Kolkata")
+    converted_times = []
+
+    for t in medicine_times:
+        try:
+            if isinstance(t, datetime):
+                utc_time = t.astimezone(utc)
+            elif isinstance(t, str):
+                if "Z" in t:
+                    utc_time = datetime.fromisoformat(t.replace("Z", "+00:00")).astimezone(utc)
+                else:
+                    utc_time = datetime.fromisoformat(t).astimezone(utc)
+            else:
+                logger.warning(f"[convert_times_to_ist] Unsupported type for medicineTime: {type(t)}")
+                continue
+
+            ist_time = utc_time.astimezone(ist)
+            converted_times.append(ist_time.strftime("%H:%M"))  # HH:MM format
+        except Exception as e:
+            logger.warning(f"[convert_times_to_ist] Error converting time '{t}': {e}")
+    return converted_times
+
+
+@app.post("/send_medicineData")
+async def send_medicineData(data: Credentials):
+    try:
+        logger.info(f"Received request: {data}")
+
+        # Step 1: Retrieve the medicines array from Firestore using user ID
+        logger.info(f"Fetching medicines data for user: {data.user}")
+        doc_ref = db.collection("users").document(data.user)
+        doc = doc_ref.get()
+
+        if not doc.exists:
+            logger.error("User data not found")
+            raise HTTPException(status_code=404, detail={"error": "User data not found"})
+
+        user_data = doc.to_dict()
+        medicines_data = user_data.get("medicines", [])  # Fetch medicines list safely
+
+        if not medicines_data:
+            logger.error("Medicines data not found for this user")
+            raise HTTPException(status_code=404, detail={"error": "Medicines data not found for this user"})
+
+        # Step 2: Extract and filter medicine details based on endDate
+        current_date = datetime.now(pytz.UTC)  # Current date in UTC
+        logger.info(f"Current date (UTC): {current_date}")
+        
+        extracted_medicines = []
+        for medicine in medicines_data:
+            end_date_raw = medicine.get("endDate")
+            if not end_date_raw:
+                logger.warning(f"Medicine missing endDate: {medicine}")
+                continue
+
+            try:
+                # Handle endDate (already converted to datetime by Firestore Admin SDK)
+                if isinstance(end_date_raw, datetime):
+                    end_date = end_date_raw
+                    if end_date.tzinfo is None:  # If no timezone info, assume UTC
+                        end_date = end_date.replace(tzinfo=pytz.UTC)
+                    else:
+                        end_date = end_date.astimezone(pytz.UTC)  # Convert to UTC for comparison
+                elif isinstance(end_date_raw, str):
+                    # Fallback for string format (e.g., "April 17, 2025 at 12:00:00 AM UTC+5:30")
+                    end_date_str = end_date_raw.replace("at ", "").replace("\u202f", " ")
+                    end_date = datetime.strptime(end_date_str, "%B %d, %Y %I:%M:%S %p UTC%z")
+                    end_date = end_date.astimezone(pytz.UTC)  # Convert to UTC for comparison
+                else:
+                    logger.warning(f"Unsupported endDate type: {type(end_date_raw)}, value: {end_date_raw}")
+                    continue
+
+                # Only include medicines with endDate in the future
+                if end_date > current_date:
+                    extracted_medicines.append({
+                        "doseFrequency": medicine.get("doseFrequency"),
+                        "endDate": medicine.get("endDate"),
+                        "medicineNames": medicine.get("medicineNames", []),
+                        "medicineTimes": convert_times_to_ist(medicine.get("medicineTimes", {})),
+                        "selectedDays": medicine.get("selectedDays", [])
+                    })
+                    
+                else:
+                    logger.info(f"Skipping medicine with expired endDate: {end_date_raw}")
+
+            except ValueError as e:
+                logger.warning(f"Failed to parse endDate: {end_date_raw}, error: {str(e)}")
+                continue
+
+        # Step 3: Check if there are any valid medicines to send
+        if not extracted_medicines:
+            logger.info("No medicines with endDate in the future found.")
+            return {
+                "message": "No medicines with endDate in the future found.",
+                "medicines": []
+            }
+
+        # Convert any non-serializable objects (e.g., timestamps)
+        extracted_medicines = convert_to_serializable(extracted_medicines)
+
+        # Step 4: Send the medicines data to ESP32
+        esp32_ip = data.esp32_ip.replace("http://", "").replace("https://", "")
+        esp32_url = f"http://{esp32_ip}/credentials"
+        logger.info(f"Sending medicines data to ESP32 at {esp32_url}")
+        esp32_response = requests.post(esp32_url, json={"medicines": extracted_medicines}, timeout=20)
+        esp32_response.raise_for_status()
+
+        logger.info("Medicines data sent successfully")
+        return {
+            "message": "Medicines data sent successfully",
+            "medicines": [
+                {
+                    "medicineNames": med.get("medicineNames", []),
+                    "medicineTimes": med.get("medicineTimes", [])
+                }
+                for med in extracted_medicines
+            ],
+            "esp32_response": esp32_response.text
+        }
+
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Request error: {str(e)}")
+        raise HTTPException(status_code=500, detail={"error": f"Failed to connect to ESP32: {str(e)}"})
+    except HTTPException as e:
+        raise e
+    except Exception as e:
+        logger.error(f"Unexpected error: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail={"error": f"Unexpected error: {str(e)}"})
+
+def send_command(data: Credentials, command: str):
+    try:
+        esp32_ip = data.esp32_ip.replace("http://", "").replace("https://", "")
+        url = f"http://{esp32_ip}/command/{command}"
+        logger.info(f"Sending command: {command} to {url}")
+        response = requests.get(url, timeout=10)
+        response.raise_for_status()
+        return {"message": f"{command.capitalize()} command sent successfully", "esp32_response": response.text}
+    except requests.exceptions.RequestException as e:
+        raise HTTPException(status_code=500, detail={"error": f"Failed to send {command} command: {str(e)}"})
+    
+
+
+def ping_device(ip: str) -> bool:
+    try:
+        # Run the ping command and capture the output
+        response = os.popen(f'ping {ip}').read()
+        
+        # Check if "Request timed out" or "Destination host unreachable" appears in the response
+        if "Request timed out" in response or "Destination host unreachable" in response:
+            return False
+        else:
+            return True
+    except Exception as e:
+        print(f"Error while pinging: {e}")
+        return False
+
+# Endpoint to check the microcontroller's availability
+@app.post("/command/microcontroller")
+def check_microcontroller(data: Credentials):
+    # First, check if the ESP32 is reachable using the ping_device function
+    if not ping_device(data.esp32_ip):
+        return {"status": "error", "message": f"Microcontroller at {data.esp32_ip} is not reachable."}
+    
+    # If reachable, return a success message without sending any command to the ESP32
+    return {"status": "success", "message": f"Microcontroller at {data.esp32_ip} is reachable."}
+
+
+@app.post("/command/reset")
+def reset_device(data: Credentials):
+    return send_command(data, "reset")
+
+@app.post("/command/camera")
+def check_camera(data: Credentials):
+    return send_command(data, "camera")
+
+@app.post("/command/lcd")
+def check_lcd(data: Credentials):
+    return send_command(data, "lcd")
+
+@app.post("/command/motor")
+def check_motor(data: Credentials):
+    return send_command(data, "motor")
+
+@app.post("/command/battery")
+def check_battery(data: Credentials):
+    return send_command(data, "battery")
+
+@app.post("/update_medicine_status")
+def update_medicine_status(req: UpdateStatusRequest):
+    try:
+        current_date = datetime.now().strftime('%d-%m-%Y')
+        print(f"[INFO] Processing for user={req.userId}, medicine={req.medicineName}, time={req.medicineTime}")
+
+        user_ref = db.collection("users").document(req.userId)
+        user_doc = user_ref.get()
+
+        if not user_doc.exists:
+            raise HTTPException(status_code=404, detail="User not found")
+
+        user_data = user_doc.to_dict()
+        medicines = user_data.get("medicines", [])
+
+        print(f"[DEBUG] Total medicine entries: {len(medicines)}")
+
+        # First, find all matches by name
+        matched_indices = [
+            idx for idx, med in enumerate(medicines)
+            if req.medicineName in med.get("medicineNames", [])
+        ]
+
+        print(f"[DEBUG] Found {len(matched_indices)} medicine(s) with name match")
+
+        target_index = None
+
+        if len(matched_indices) == 1:
+            target_index = matched_indices[0]
+        else:
+            # Multiple matches, match by time
+            for idx in matched_indices:
+                for ts in medicines[idx].get("medicineTimes", []):
+                    try:
+                        if hasattr(ts, "strftime"):
+                            time_str = ts.strftime("%H:%M")
+                            print(f"[TRACE] Comparing time: {time_str} == {req.medicineTime}")
+                            if time_str == req.medicineTime:
+                                target_index = idx
+                                break
+                    except Exception as e:
+                        print(f"[ERROR] Timestamp parsing failed: {e}")
+                if target_index is not None:
+                    break
+
+        if target_index is None:
+            raise HTTPException(status_code=404, detail="Matching medicine name and time not found.")
+
+        # Update the status
+        print(f"[INFO] Updating index {target_index}")
+        if "status" not in medicines[target_index]:
+            medicines[target_index]["status"] = {}
+        medicines[target_index]["status"][current_date] = "taken"
+
+        # Push the full list back
+        user_ref.update({"medicines": medicines})
+        print(f"[SUCCESS] Updated medicine status at index {target_index}")
+
+        return {"message": f"Medicine status updated at index {target_index}"}
+
+    except Exception as e:
+        print(f"[ERROR] {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+    
+class BuzzerRequest(BaseModel):
+    esp32_ip: str
+    sound_type: str  # Options: relaxing, soft_melody, gentle_chime, calm_tune, beep_beep
+
+@app.post("/buzzer/play")
+def play_buzzer(data: BuzzerRequest):
+    valid_sounds = ["relaxing", "soft_melody", "gentle_chime", "calm_tune", "beep_beep"]
+
+    if data.sound_type not in valid_sounds:
+        raise HTTPException(status_code=400, detail="Invalid sound type selected.")
+
+    try:
+        url = f"http://{data.esp32_ip}/play_buzzer?sound={data.sound_type}"
+        response = requests.get(url, timeout=5)
+        response.raise_for_status()
+        return {
+            "status": "success",
+            "message": f"Playing {data.sound_type} on ESP32",
+            "esp32_response": response.text
+        }
+    except requests.RequestException as e:
+        raise HTTPException(status_code=500, detail=f"Failed to send buzzer command: {e}")
+
+if __name__ == "__main__":
+    import os
+    port = int(os.environ.get("PORT", 5000))
+    uvicorn.run("app:app", host="0.0.0.0", port=port, reload=True)