added

Dockerfile

@@ -18,6 +18,11 @@ RUN pip install --no-cache-dir -r requirements.txt
 # Copy application code
 COPY . .
 
+# Expose port (Hugging Face Spaces expects 7860, but FastAPI default is 3000)
+EXPOSE 7860
 
-# Run the automation script
-CMD ["python", "main.py"]
+# Set environment variable for Hugging Face Spaces
+ENV PORT=7860
+
+# Start FastAPI server on the expected port
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

app/config.py

@@ -0,0 +1,13 @@
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+LOG_LEVEL = os.environ.get("LOG_LEVEL", "INFO").upper()
+LOG_FILE = os.environ.get("LOG_FILE", "send_notifications.log")
+LOG_MAX_BYTES = int(os.environ.get("LOG_MAX_BYTES", 10 * 1024 * 1024))
+LOG_BACKUP_COUNT = int(os.environ.get("LOG_BACKUP_COUNT", 5))
+
+SUPABASE_URL = os.environ.get("SUPABASE_URL")
+SUPABASE_KEY = os.environ.get("SUPABASE_KEY")
+FIREBASE_SERVICE_ACCOUNT_JSON = os.environ.get("FIREBASE_SERVICE_ACCOUNT_JSON")

app/main.py

@@ -0,0 +1,22 @@
+
+from fastapi import FastAPI
+import threading
+import uvicorn
+from app.services.notification_service import notification_service
+from app.services.firebase import *  # Ensure Firebase is initialized
+
+app = FastAPI()
+
+@app.get("/")
+def read_root():
+    return {"message": "Notification Service is running"}
+
+def start_notification_service():
+    notification_service()
+
+if __name__ == "__main__":
+    # Start notification service in a background thread
+    notif_thread = threading.Thread(target=start_notification_service, daemon=True)
+    notif_thread.start()
+    # Run FastAPI server in the main thread
+    uvicorn.run("app.main:app", host="0.0.0.0", port=8000, reload=False)

app/models/notification_models.py

@@ -0,0 +1,16 @@
+from typing import List, Optional, Dict, Any
+from pydantic import BaseModel
+
+class Notification(BaseModel):
+    title: str
+    body: str
+    type: str
+    priority: Optional[str] = "normal"
+    event_id: int
+    user_ids: List[int]
+    ids: List[int]
+    data: Optional[List[Dict[str, Any]]] = None
+
+class FCMToken(BaseModel):
+    user_id: int
+    fcm_token: str

app/services/database.py

@@ -0,0 +1,9 @@
+from supabase import create_client
+from app.config import SUPABASE_URL, SUPABASE_KEY
+from app.utils.logging_config import log
+
+if not SUPABASE_URL or not SUPABASE_KEY:
+    log.critical("SUPABASE_URL and SUPABASE_KEY must be set in environment variables")
+    raise EnvironmentError("SUPABASE_URL and SUPABASE_KEY must be set in environment variables")
+
+supabase = create_client(SUPABASE_URL, SUPABASE_KEY)

app/services/firebase.py

@@ -0,0 +1,18 @@
+import json
+import firebase_admin
+from firebase_admin import credentials
+from app.config import FIREBASE_SERVICE_ACCOUNT_JSON
+from app.utils.logging_config import log
+
+if not FIREBASE_SERVICE_ACCOUNT_JSON:
+    log.critical("FIREBASE_SERVICE_ACCOUNT_JSON environment variable not set")
+    raise EnvironmentError("FIREBASE_SERVICE_ACCOUNT_JSON environment variable not set")
+
+service_account = json.loads(FIREBASE_SERVICE_ACCOUNT_JSON)
+cred = credentials.Certificate(service_account)
+try:
+    firebase_admin.initialize_app(cred)
+    log.info("Initialized Firebase app with provided service account")
+except Exception as e:
+    log.exception("Failed to initialize Firebase admin: %s", e)
+    raise

main.py → app/services/notification_service.py

@@ -1,81 +1,12 @@
-
-import os
-import json
 import time
-import logging
-from logging.handlers import RotatingFileHandler
-from typing import List, Optional, Dict, Any
-from dotenv import load_dotenv
-from supabase import create_client
-import firebase_admin
-from firebase_admin import credentials, messaging
-import requests
-from fastapi import FastAPI, HTTPException
-from pydantic import BaseModel
-
-
-# Load environment variables from .env file
-load_dotenv()
-
-# --- Logging configuration -------------------------------------------------
-LOG_LEVEL = os.environ.get("LOG_LEVEL", "INFO").upper()
-LOG_FILE = os.environ.get("LOG_FILE", "send_notifications.log")
-LOG_MAX_BYTES = int(os.environ.get("LOG_MAX_BYTES", 10 * 1024 * 1024))  # 10MB
-LOG_BACKUP_COUNT = int(os.environ.get("LOG_BACKUP_COUNT", 5))
-
-logger = logging.getLogger("send_notifications")
-if not logger.handlers:
-    logger.setLevel(LOG_LEVEL)
-    # Console handler
-    ch = logging.StreamHandler()
-    ch.setLevel(LOG_LEVEL)
-    ch_formatter = logging.Formatter(
-        "%(asctime)s.%(msecs)03d %(levelname)s [%(name)s] %(message)s",
-        datefmt="%Y-%m-%d %H:%M:%S",
-    )
-    ch.setFormatter(ch_formatter)
-    logger.addHandler(ch)
-
-    # Rotating file handler
-    try:
-        fh = RotatingFileHandler(LOG_FILE, maxBytes=LOG_MAX_BYTES, backupCount=LOG_BACKUP_COUNT)
-        fh.setLevel(LOG_LEVEL)
-        fh.setFormatter(ch_formatter)
-        logger.addHandler(fh)
-    except Exception as e:
-        logger.warning("Failed to create file handler for logging: %s", e)
-
-# Convenience alias for root logger
-log = logger
-
-# Supabase config
-SUPABASE_URL = os.environ.get("SUPABASE_URL")
-SUPABASE_KEY = os.environ.get("SUPABASE_KEY")
-if not SUPABASE_URL or not SUPABASE_KEY:
-    log.critical("SUPABASE_URL and SUPABASE_KEY must be set in environment variables")
-    raise EnvironmentError("SUPABASE_URL and SUPABASE_KEY must be set in environment variables")
-
-# Initialize supabase client
-supabase = create_client(SUPABASE_URL, SUPABASE_KEY)
-
-# Firebase config
-service_account_json = os.environ.get("FIREBASE_SERVICE_ACCOUNT_JSON")
-if not service_account_json:
-    log.critical("FIREBASE_SERVICE_ACCOUNT_JSON environment variable not set")
-    raise EnvironmentError("FIREBASE_SERVICE_ACCOUNT_JSON environment variable not set")
-service_account = json.loads(service_account_json)
-cred = credentials.Certificate(service_account)
-try:
-    firebase_admin.initialize_app(cred)
-    log.info("Initialized Firebase app with provided service account")
-except Exception as e:
-    log.exception("Failed to initialize Firebase admin: %s", e)
-    raise
-
+import json
+from typing import List, Dict, Any
+from firebase_admin import messaging
+from app.services.database import supabase
+from app.utils.logging_config import log
 
-# --- Efficient Notification Service ---
+# --- Data Fetching Functions ---
 def fetch_user_notifications():
-    """Fetch all pending user_notifications efficiently via Supabase client."""
     log.debug("Fetching user_notifications from Supabase")
     start = time.time()
     resp = supabase.table("user_notifications").select("*").execute()
@@ -89,15 +20,11 @@ def fetch_user_notifications():
     return data or []
 
 def fetch_event_attendance_for_events(event_ids: List[int]) -> List[Dict[str, Any]]:
-    """Fetch attendance rows for multiple event_ids in one query."""
     if not event_ids:
         return []
     log.debug("Fetching event_attendance for event_ids: %s", event_ids)
     start = time.time()
-    resp = supabase.table("event_attendance").select("*").eq("event_id", 201).execute()
-    print(resp.data)
-
-    print(resp)
+    resp = supabase.table("event_attendance").select("*").in_("event_id", event_ids).execute()
     data = getattr(resp, "data", None) or (resp.get("data") if isinstance(resp, dict) else None)
     error = getattr(resp, "error", None) or (resp.get("error") if isinstance(resp, dict) else None)
     if error:
@@ -108,7 +35,6 @@ def fetch_event_attendance_for_events(event_ids: List[int]) -> List[Dict[str, An
     return data or []
 
 def fetch_fcm_tokens_for_users(user_ids: List[int]) -> List[Dict[str, Any]]:
-    """Fetch fcm tokens for multiple users in one query."""
     if not user_ids:
         return []
     log.debug("Fetching FCM tokens for user_ids (count=%d)", len(user_ids))
@@ -185,14 +111,11 @@ def send_fcm(tokens, title, body, data):
     if not tokens:
         log.debug("No tokens provided to send_fcm")
         return None
-    # Firebase FCM requires all values in the `data` dict to be strings.
-    # Ensure we coerce non-string values to strings and handle None.
     def _sanitize_data(d):
         if not d:
             return {}
         out = {}
         for k, v in d.items():
-            # keys must be strings as well
             key = str(k)
             if v is None:
                 out[key] = ""
@@ -204,9 +127,7 @@ def send_fcm(tokens, title, body, data):
                 except Exception:
                     out[key] = str(v)
         return out
-
     safe_data = _sanitize_data(data)
-
     message = messaging.MulticastMessage(
         notification=messaging.Notification(title=title, body=body),
         data=safe_data,
@@ -224,19 +145,14 @@ def send_fcm(tokens, title, body, data):
 def notification_service():
     while True:
         try:
-            # 1. Query user_notifications
             notifications = fetch_user_notifications()
             if not notifications:
                 log.debug("No notifications to process. Sleeping for 10 minutes.")
                 time.sleep(600)
                 continue
-
-            # 2. Aggregate by event_id
             agg = aggregate_notifications(notifications)
-            # Batch fetch attendance for all events we need
             event_ids = list(agg.keys())
             attendance_rows = fetch_event_attendance_for_events(event_ids)
-            # build attendance_map: event_id -> [user_id]
             attendance_map: Dict[int, List[int]] = {}
             for r in attendance_rows:
                 eid = r.get("event_id")
@@ -244,30 +160,21 @@ def notification_service():
                 if eid is None or uid is None:
                     continue
                 attendance_map.setdefault(eid, []).append(uid)
-
-            # Collect distinct user ids across all events and also include user_ids from notifications
             all_user_ids = set()
             for v in agg.values():
                 all_user_ids.update(v["user_ids"])
             for ulist in attendance_map.values():
                 all_user_ids.update(ulist)
             all_user_ids = list(all_user_ids)
-
-            # Batch fetch tokens
             token_rows = fetch_fcm_tokens_for_users(all_user_ids)
             token_map: Dict[int, str] = {r["user_id"]: r["fcm_token"] for r in token_rows}
-
             for event_id, notif in agg.items():
-                # 3. Get attendees for event (from pre-fetched attendance_map)
                 user_ids = attendance_map.get(event_id, [])
-                # 4. Get FCM tokens for users (from pre-fetched token_map)
                 tokens = [token_map.get(uid) for uid in user_ids]
                 tokens = [t for t in tokens if t]
-                # 5. Send notification
                 data = {"event_id": event_id, "type": notif["type"], "priority": notif["priority"]}
                 response = send_fcm(tokens, notif["title"], notif["body"], data)
                 log.info("Sent notification for event %s to %d users. fcm_response=%s", event_id, len(tokens), getattr(response, 'success_count', response))
-                # 6. Upsert notification record
                 upsert_payload = [{
                     "title": notif["title"],
                     "message": notif["body"],
@@ -278,13 +185,8 @@ def notification_service():
                     "metadata": data
                 }]
                 upsert_notifications(upsert_payload)
-                # 7. Delete processed notifications in bulk
                 delete_user_notifications_by_ids(notif["ids"])
                 log.debug("Deleted processed notifications for event %s.", event_id)
         except Exception as e:
             log.exception("Error in notification service main loop: %s", e)
-        time.sleep(600)  # 10 minutes
-
-# --- Run service if main ---
-if __name__ == "__main__":
-    notification_service()
+        time.sleep(600)

app/utils/logging_config.py

@@ -0,0 +1,24 @@
+import logging
+from logging.handlers import RotatingFileHandler
+from app.config import LOG_LEVEL, LOG_FILE, LOG_MAX_BYTES, LOG_BACKUP_COUNT
+
+logger = logging.getLogger("send_notifications")
+if not logger.handlers:
+    logger.setLevel(LOG_LEVEL)
+    ch = logging.StreamHandler()
+    ch.setLevel(LOG_LEVEL)
+    ch_formatter = logging.Formatter(
+        "%(asctime)s.%(msecs)03d %(levelname)s [%(name)s] %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+    ch.setFormatter(ch_formatter)
+    logger.addHandler(ch)
+    try:
+        fh = RotatingFileHandler(LOG_FILE, maxBytes=LOG_MAX_BYTES, backupCount=LOG_BACKUP_COUNT)
+        fh.setLevel(LOG_LEVEL)
+        fh.setFormatter(ch_formatter)
+        logger.addHandler(fh)
+    except Exception as e:
+        logger.warning("Failed to create file handler for logging: %s", e)
+
+log = logger

send_notifications.log

@@ -162,3 +162,12 @@ ValueError: Message.data must not contain non-string values.
 2025-09-29 21:10:50.094 DEBUG [send_notifications] Deleting 3 user_notifications
 2025-09-29 21:10:50.331 INFO [send_notifications] Deleted 3 user_notifications in 0.238s
 2025-09-29 21:10:50.332 DEBUG [send_notifications] Deleted processed notifications for event 201.
+2025-09-30 20:42:12.112 INFO [send_notifications] Initialized Firebase app with provided service account
+2025-09-30 20:42:12.113 DEBUG [send_notifications] Fetching user_notifications from Supabase
+2025-09-30 20:42:13.065 INFO [send_notifications] Fetched 0 user_notifications in 0.952s
+2025-09-30 20:42:13.065 DEBUG [send_notifications] No notifications to process. Sleeping for 10 minutes.
+2025-09-30 20:51:10.751 INFO [send_notifications] Initialized Firebase app with provided service account
+2025-09-30 20:51:45.015 INFO [send_notifications] Initialized Firebase app with provided service account
+2025-09-30 20:51:45.015 DEBUG [send_notifications] Fetching user_notifications from Supabase
+2025-09-30 20:51:46.065 INFO [send_notifications] Fetched 0 user_notifications in 1.049s
+2025-09-30 20:51:46.065 DEBUG [send_notifications] No notifications to process. Sleeping for 10 minutes.