Upload folder using huggingface_hub

.env.example

@@ -0,0 +1,14 @@
+SECRET_KEY=change-this-secret
+DEBUG=True
+PORT=8000
+FRONTEND_URL=http://localhost:3000
+ALLOWED_HOSTS=localhost,127.0.0.1
+
+# Supabase Postgres connection string.
+# Example: postgresql://postgres:<password>@db.<project-ref>.supabase.co:5432/postgres
+DATABASE_URL=
+SUPABASE_URL=
+SUPABASE_ANON_KEY=
+
+# Optional, only needed for Google sign-in.
+GOOGLE_CLIENT_ID=

.gitignore

@@ -0,0 +1,2 @@
+/node_modules
+/.env

Dockerfile

@@ -0,0 +1,33 @@
+FROM python:3.10-slim
+
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+ENV PORT=7860
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    libpq-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# Copy requirements and install
+COPY requirements.txt /app/
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application code
+COPY . /app/
+
+# Hugging Face Spaces runs as user 1000 (non-root)
+RUN chown -R 1000:1000 /app
+
+# Expose the port Hugging Face Spaces expects
+EXPOSE 7860
+
+# Switch to the non-root user
+USER 1000
+
+# Run migrations and start Daphne ASGI server
+CMD python manage.py migrate --noinput && daphne -b 0.0.0.0 -p 7860 flux_backend.asgi:application

apps/__init__.py

@@ -0,0 +1 @@
+

apps/accounts/__init__.py

@@ -0,0 +1 @@
+

apps/accounts/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class AccountsConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "apps.accounts"

apps/accounts/auth_urls.py

@@ -0,0 +1,9 @@
+from django.urls import path
+
+from . import views
+
+
+urlpatterns = [
+    path("google", views.google_login),
+    path("supabase", views.supabase_login),
+]

apps/accounts/migrations/0001_initial.py

@@ -0,0 +1,37 @@
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+    initial = True
+
+    dependencies = []
+
+    operations = [
+        migrations.CreateModel(
+            name="UserAccount",
+            fields=[
+                ("id", models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID")),
+                ("name", models.CharField(max_length=255)),
+                ("username", models.CharField(max_length=255, unique=True)),
+                ("password", models.CharField(max_length=255)),
+                ("token", models.CharField(blank=True, db_index=True, max_length=80, null=True)),
+                ("google_id", models.CharField(blank=True, max_length=255, null=True, unique=True)),
+                ("profile_picture", models.URLField(blank=True, null=True)),
+                ("created_at", models.DateTimeField(auto_now_add=True)),
+                ("updated_at", models.DateTimeField(auto_now=True)),
+            ],
+        ),
+        migrations.CreateModel(
+            name="Meeting",
+            fields=[
+                ("id", models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID")),
+                ("meeting_code", models.CharField(max_length=255)),
+                ("date", models.DateTimeField(auto_now_add=True)),
+                ("user", models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name="meetings", to="accounts.useraccount")),
+            ],
+            options={
+                "ordering": ["-date"],
+            },
+        ),
+    ]

apps/accounts/migrations/__init__.py

@@ -0,0 +1 @@
+

apps/accounts/models.py

@@ -0,0 +1,27 @@
+from django.db import models
+
+
+class UserAccount(models.Model):
+    name = models.CharField(max_length=255)
+    username = models.CharField(max_length=255, unique=True)
+    password = models.CharField(max_length=255)
+    token = models.CharField(max_length=80, blank=True, null=True, db_index=True)
+    google_id = models.CharField(max_length=255, unique=True, blank=True, null=True)
+    profile_picture = models.URLField(blank=True, null=True)
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    def __str__(self):
+        return self.username
+
+
+class Meeting(models.Model):
+    user = models.ForeignKey(UserAccount, on_delete=models.CASCADE, related_name="meetings")
+    meeting_code = models.CharField(max_length=255)
+    date = models.DateTimeField(auto_now_add=True)
+
+    class Meta:
+        ordering = ["-date"]
+
+    def __str__(self):
+        return f"{self.user.username} - {self.meeting_code}"

apps/accounts/serializers.py

@@ -0,0 +1,12 @@
+from rest_framework import serializers
+
+from .models import Meeting
+
+
+class MeetingSerializer(serializers.ModelSerializer):
+    user_id = serializers.CharField(source="user.username", read_only=True)
+    meetingCode = serializers.CharField(source="meeting_code", read_only=True)
+
+    class Meta:
+        model = Meeting
+        fields = ["id", "user_id", "meetingCode", "date"]

apps/accounts/urls.py

@@ -0,0 +1,13 @@
+from django.urls import path
+
+from . import views
+
+
+urlpatterns = [
+    path("login", views.login),
+    path("register", views.register),
+    path("add_to_activity", views.add_to_history),
+    path("get_all_activity", views.get_user_history),
+    path("delete_meeting/<str:meeting_code>", views.delete_meeting),
+    path("delete_all_meetings", views.delete_all_meetings),
+]

apps/accounts/views.py

@@ -0,0 +1,215 @@
+import secrets
+
+import requests
+from django.conf import settings
+from django.contrib.auth.hashers import check_password, make_password
+from google.auth.transport import requests as google_requests
+from google.oauth2 import id_token
+from rest_framework import status
+from rest_framework.decorators import api_view
+from rest_framework.response import Response
+
+from .models import Meeting, UserAccount
+from .serializers import MeetingSerializer
+
+
+def _public_user(user):
+    return {
+        "name": user.name,
+        "username": user.username,
+        "profilePicture": user.profile_picture,
+    }
+
+
+def _issue_token(user):
+    user.token = secrets.token_hex(20)
+    user.save(update_fields=["token", "updated_at"])
+    return user.token
+
+
+def _get_user_by_token(token):
+    if not token:
+        return None
+    return UserAccount.objects.filter(token=token).first()
+
+
+@api_view(["POST"])
+def register(request):
+    name = request.data.get("name")
+    username = request.data.get("username")
+    password = request.data.get("password")
+
+    if not name or not username or not password:
+        return Response({"message": "Please Provide"}, status=status.HTTP_400_BAD_REQUEST)
+
+    if UserAccount.objects.filter(username=username).exists():
+        return Response({"message": "User already exists"}, status=status.HTTP_302_FOUND)
+
+    UserAccount.objects.create(
+        name=name,
+        username=username,
+        password=make_password(password),
+    )
+
+    return Response({"message": "User Registered"}, status=status.HTTP_201_CREATED)
+
+
+@api_view(["POST"])
+def login(request):
+    username = request.data.get("username")
+    password = request.data.get("password")
+
+    if not username or not password:
+        return Response({"message": "Please Provide"}, status=status.HTTP_400_BAD_REQUEST)
+
+    user = UserAccount.objects.filter(username=username).first()
+    if not user:
+        return Response({"message": "User Not Found"}, status=status.HTTP_404_NOT_FOUND)
+
+    if not check_password(password, user.password):
+        return Response({"message": "Invalid Username or password"}, status=status.HTTP_401_UNAUTHORIZED)
+
+    token = _issue_token(user)
+    return Response({"token": token, "user": _public_user(user)}, status=status.HTTP_200_OK)
+
+
+@api_view(["GET"])
+def get_user_history(request):
+    user = _get_user_by_token(request.query_params.get("token"))
+    if not user:
+        return Response({"message": "User not found"}, status=status.HTTP_404_NOT_FOUND)
+
+    return Response(MeetingSerializer(user.meetings.all(), many=True).data, status=status.HTTP_200_OK)
+
+
+@api_view(["POST"])
+def add_to_history(request):
+    user = _get_user_by_token(request.data.get("token"))
+    if not user:
+        return Response({"message": "User not found"}, status=status.HTTP_404_NOT_FOUND)
+
+    meeting_code = request.data.get("meeting_code")
+    if not meeting_code:
+        return Response({"message": "meeting_code is required"}, status=status.HTTP_400_BAD_REQUEST)
+
+    Meeting.objects.create(user=user, meeting_code=meeting_code)
+    return Response({"message": "Added code to history"}, status=status.HTTP_201_CREATED)
+
+
+@api_view(["DELETE"])
+def delete_meeting(request, meeting_code):
+    user = _get_user_by_token(request.query_params.get("token"))
+    if not user:
+        return Response({"message": "User not found"}, status=status.HTTP_404_NOT_FOUND)
+
+    deleted_count, _ = Meeting.objects.filter(user=user, meeting_code=meeting_code).delete()
+    if deleted_count == 0:
+        return Response({"message": "Meeting not found"}, status=status.HTTP_404_NOT_FOUND)
+
+    return Response({"message": "Meeting deleted successfully"}, status=status.HTTP_200_OK)
+
+
+@api_view(["DELETE"])
+def delete_all_meetings(request):
+    user = _get_user_by_token(request.query_params.get("token"))
+    if not user:
+        return Response({"message": "User not found"}, status=status.HTTP_404_NOT_FOUND)
+
+    Meeting.objects.filter(user=user).delete()
+    return Response({"message": "All meetings deleted successfully"}, status=status.HTTP_200_OK)
+
+
+@api_view(["POST"])
+def google_login(request):
+    credential = request.data.get("token")
+    if not credential:
+        return Response({"message": "Token is required"}, status=status.HTTP_400_BAD_REQUEST)
+
+    if not settings.GOOGLE_CLIENT_ID:
+        return Response({"message": "Google login is not configured"}, status=status.HTTP_503_SERVICE_UNAVAILABLE)
+
+    try:
+        payload = id_token.verify_oauth2_token(
+            credential,
+            google_requests.Request(),
+            settings.GOOGLE_CLIENT_ID,
+        )
+    except ValueError:
+        return Response({"message": "Invalid Google token. Please try again."}, status=status.HTTP_401_UNAUTHORIZED)
+
+    email = payload.get("email")
+    google_id = payload.get("sub")
+    name = payload.get("name") or email
+    picture = payload.get("picture")
+
+    user = UserAccount.objects.filter(username=email).first()
+    if not user:
+        user = UserAccount.objects.create(
+            name=name,
+            username=email,
+            password=make_password(secrets.token_hex(16)),
+            google_id=google_id,
+            profile_picture=picture,
+        )
+    else:
+        user.google_id = user.google_id or google_id
+        user.profile_picture = picture or user.profile_picture
+        user.name = user.name or name
+        user.save(update_fields=["google_id", "profile_picture", "name", "updated_at"])
+
+    token = _issue_token(user)
+    return Response({"token": token, "user": _public_user(user)}, status=status.HTTP_200_OK)
+
+
+@api_view(["POST"])
+def supabase_login(request):
+    access_token = request.data.get("access_token")
+    if not access_token:
+        return Response({"message": "access_token is required"}, status=status.HTTP_400_BAD_REQUEST)
+
+    if not settings.SUPABASE_URL or not settings.SUPABASE_ANON_KEY:
+        return Response({"message": "Supabase auth is not configured"}, status=status.HTTP_503_SERVICE_UNAVAILABLE)
+
+    try:
+        supabase_response = requests.get(
+            f"{settings.SUPABASE_URL.rstrip('/')}/auth/v1/user",
+            headers={
+                "apikey": settings.SUPABASE_ANON_KEY,
+                "Authorization": f"Bearer {access_token}",
+            },
+            timeout=10,
+        )
+    except requests.RequestException:
+        return Response({"message": "Could not verify Supabase session"}, status=status.HTTP_503_SERVICE_UNAVAILABLE)
+
+    if supabase_response.status_code != 200:
+        return Response({"message": "Invalid Supabase session"}, status=status.HTTP_401_UNAUTHORIZED)
+
+    supabase_user = supabase_response.json()
+    email = supabase_user.get("email")
+    metadata = supabase_user.get("user_metadata") or {}
+
+    if not email:
+        return Response({"message": "Supabase user email is missing"}, status=status.HTTP_400_BAD_REQUEST)
+
+    name = metadata.get("full_name") or metadata.get("name") or email
+    picture = metadata.get("avatar_url") or metadata.get("picture")
+    provider_id = supabase_user.get("id")
+
+    user = UserAccount.objects.filter(username=email).first()
+    if not user:
+        user = UserAccount.objects.create(
+            name=name,
+            username=email,
+            password=make_password(secrets.token_hex(16)),
+            google_id=provider_id,
+            profile_picture=picture,
+        )
+    else:
+        user.name = name or user.name
+        user.google_id = user.google_id or provider_id
+        user.profile_picture = picture or user.profile_picture
+        user.save(update_fields=["name", "google_id", "profile_picture", "updated_at"])
+
+    token = _issue_token(user)
+    return Response({"token": token, "user": _public_user(user)}, status=status.HTTP_200_OK)

apps/calls/__init__.py

@@ -0,0 +1 @@
+

apps/calls/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class CallsConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "apps.calls"

apps/calls/consumers.py

@@ -0,0 +1,142 @@
+import uuid
+
+from channels.generic.websocket import AsyncJsonWebsocketConsumer
+
+
+rooms = {}
+
+
+class CallConsumer(AsyncJsonWebsocketConsumer):
+    async def connect(self):
+        self.room_code = self.scope["url_route"]["kwargs"]["room_code"]
+        self.room_group_name = f"call_{self.room_code}"
+        self.client_id = uuid.uuid4().hex
+        self.username = "Guest"
+
+        await self.channel_layer.group_add(self.room_group_name, self.channel_name)
+        await self.accept()
+        await self.send_json({"event": "connect", "socketId": self.client_id})
+
+    async def disconnect(self, close_code):
+        room = rooms.get(self.room_code, {})
+        was_joined = self.client_id in room
+
+        if was_joined:
+            room.pop(self.client_id, None)
+            if not room:
+                rooms.pop(self.room_code, None)
+
+            await self.channel_layer.group_send(
+                self.room_group_name,
+                {
+                    "type": "room_event",
+                    "sender_channel_name": self.channel_name,
+                    "payload": {
+                        "event": "user-left",
+                        "socketId": self.client_id,
+                    },
+                },
+            )
+
+        await self.channel_layer.group_discard(self.room_group_name, self.channel_name)
+
+    async def receive_json(self, content):
+        event = content.get("event")
+
+        if event == "username":
+            self.username = content.get("username") or "Guest"
+            room = rooms.get(self.room_code, {})
+            if self.client_id in room:
+                room[self.client_id]["username"] = self.username
+                await self._broadcast({
+                    "event": "username",
+                    "socketId": self.client_id,
+                    "username": self.username,
+                })
+            return
+
+        if event == "join-call":
+            room = rooms.setdefault(self.room_code, {})
+            existing_users = [
+                {"socketId": socket_id, "username": participant["username"]}
+                for socket_id, participant in room.items()
+                if socket_id != self.client_id
+            ]
+
+            room[self.client_id] = {
+                "channel_name": self.channel_name,
+                "username": self.username,
+            }
+
+            await self.send_json({"event": "room-users", "users": existing_users})
+            await self._broadcast({
+                "event": "user-joined",
+                "user": {
+                    "socketId": self.client_id,
+                    "username": self.username,
+                },
+            })
+            return
+
+        if event == "signal":
+            await self._send_to_peer(
+                content.get("toId"),
+                {
+                    "event": "signal",
+                    "fromSocketId": self.client_id,
+                    "message": content.get("message"),
+                },
+            )
+            return
+
+        if event == "chat-message":
+            await self._broadcast(
+                {
+                    "event": "chat-message",
+                    "data": content.get("data", ""),
+                    "sender": content.get("sender") or self.username,
+                    "socketIdSender": self.client_id,
+                },
+                include_sender=False,
+            )
+            return
+
+        if event in ("screen-share-started", "screen-share-stopped"):
+            await self._broadcast(
+                {
+                    "event": event,
+                    "sharerSocketId": content.get("sharerSocketId") or self.client_id,
+                },
+                include_sender=False,
+            )
+
+    async def _send_to_peer(self, socket_id, payload):
+        participant = rooms.get(self.room_code, {}).get(socket_id)
+        if not participant:
+            return
+
+        await self.channel_layer.send(
+            participant["channel_name"],
+            {
+                "type": "direct_event",
+                "payload": payload,
+            },
+        )
+
+    async def _broadcast(self, payload, include_sender=True):
+        await self.channel_layer.group_send(
+            self.room_group_name,
+            {
+                "type": "room_event",
+                "sender_channel_name": None if include_sender else self.channel_name,
+                "payload": payload,
+            },
+        )
+
+    async def room_event(self, event):
+        if event.get("sender_channel_name") == self.channel_name:
+            return
+        await self.send_json(event["payload"])
+
+    async def direct_event(self, event):
+        await self.send_json(event["payload"])

apps/calls/routing.py

@@ -0,0 +1,8 @@
+from django.urls import re_path
+
+from .consumers import CallConsumer
+
+
+websocket_urlpatterns = [
+    re_path(r"ws/call/(?P<room_code>[^/]+)/$", CallConsumer.as_asgi()),
+]

flux_backend/__init__.py

@@ -0,0 +1 @@
+

flux_backend/asgi.py

@@ -0,0 +1,14 @@
+import os
+
+from channels.routing import ProtocolTypeRouter, URLRouter
+from django.core.asgi import get_asgi_application
+
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "flux_backend.settings")
+
+from apps.calls.routing import websocket_urlpatterns
+
+application = ProtocolTypeRouter({
+    "http": get_asgi_application(),
+    "websocket": URLRouter(websocket_urlpatterns),
+})

flux_backend/settings.py

@@ -0,0 +1,98 @@
+import os
+from pathlib import Path
+from urllib.parse import unquote, urlparse
+
+from dotenv import load_dotenv
+
+
+BASE_DIR = Path(__file__).resolve().parent.parent
+load_dotenv(BASE_DIR / ".env")
+
+SECRET_KEY = os.environ.get("SECRET_KEY", "django-insecure-flux-local-key")
+DEBUG = os.environ.get("DEBUG", "True").lower() in ("1", "true", "yes", "on")
+ALLOWED_HOSTS = [
+    host.strip()
+    for host in os.environ.get("ALLOWED_HOSTS", "localhost,127.0.0.1").split(",")
+    if host.strip()
+]
+
+if DEBUG and "*" not in ALLOWED_HOSTS:
+    ALLOWED_HOSTS.append("*")
+
+INSTALLED_APPS = [
+    "daphne",
+    "django.contrib.auth",
+    "django.contrib.contenttypes",
+    "django.contrib.sessions",
+    "django.contrib.staticfiles",
+    "corsheaders",
+    "rest_framework",
+    "channels",
+    "apps.accounts",
+    "apps.calls",
+]
+
+MIDDLEWARE = [
+    "corsheaders.middleware.CorsMiddleware",
+    "django.middleware.security.SecurityMiddleware",
+    "django.contrib.sessions.middleware.SessionMiddleware",
+    "django.middleware.common.CommonMiddleware",
+]
+
+ROOT_URLCONF = "flux_backend.urls"
+ASGI_APPLICATION = "flux_backend.asgi.application"
+WSGI_APPLICATION = "flux_backend.wsgi.application"
+
+DATABASE_URL = os.environ.get("DATABASE_URL", "").strip()
+if DATABASE_URL:
+    parsed_db = urlparse(DATABASE_URL)
+    DATABASES = {
+        "default": {
+            "ENGINE": "django.db.backends.postgresql",
+            "NAME": parsed_db.path.lstrip("/"),
+            "USER": unquote(parsed_db.username or ""),
+            "PASSWORD": unquote(parsed_db.password or ""),
+            "HOST": parsed_db.hostname,
+            "PORT": parsed_db.port or 5432,
+            "OPTIONS": {"sslmode": "require"},
+        }
+    }
+else:
+    DATABASES = {
+        "default": {
+            "ENGINE": "django.db.backends.sqlite3",
+            "NAME": BASE_DIR / "db.sqlite3",
+        }
+    }
+
+REST_FRAMEWORK = {
+    "DEFAULT_PERMISSION_CLASSES": [
+        "rest_framework.permissions.AllowAny",
+    ],
+}
+
+FRONTEND_URL = os.environ.get("FRONTEND_URL", "http://localhost:3000")
+CORS_ALLOW_ALL_ORIGINS = os.environ.get("CORS_ALLOW_ALL_ORIGINS", "True").lower() in ("1", "true", "yes", "on")
+CORS_ALLOW_CREDENTIALS = True
+CORS_ALLOWED_ORIGINS = [
+    origin.strip()
+    for origin in os.environ.get("CORS_ALLOWED_ORIGINS", FRONTEND_URL).split(",")
+    if origin.strip()
+]
+
+CHANNEL_LAYERS = {
+    "default": {
+        "BACKEND": "channels.layers.InMemoryChannelLayer",
+    },
+}
+
+LANGUAGE_CODE = "en-us"
+TIME_ZONE = "UTC"
+USE_I18N = True
+USE_TZ = True
+STATIC_URL = "static/"
+DEFAULT_AUTO_FIELD = "django.db.models.BigAutoField"
+
+GOOGLE_CLIENT_ID = os.environ.get("GOOGLE_CLIENT_ID", "")
+SUPABASE_URL = os.environ.get("SUPABASE_URL", "")
+SUPABASE_ANON_KEY = os.environ.get("SUPABASE_ANON_KEY", "")

flux_backend/urls.py

@@ -0,0 +1,13 @@
+from django.http import JsonResponse
+from django.urls import include, path
+
+
+def health(_request):
+    return JsonResponse({"status": "ok", "message": "Server is running"})
+
+
+urlpatterns = [
+    path("health", health),
+    path("api/v1/users/", include("apps.accounts.urls")),
+    path("api/v1/auth/", include("apps.accounts.auth_urls")),
+]

flux_backend/wsgi.py

@@ -0,0 +1,8 @@
+import os
+
+from django.core.wsgi import get_wsgi_application
+
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "flux_backend.settings")
+
+application = get_wsgi_application()

manage.py

@@ -0,0 +1,14 @@
+#!/usr/bin/env python
+import os
+import sys
+
+
+def main():
+    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "flux_backend.settings")
+    from django.core.management import execute_from_command_line
+
+    execute_from_command_line(sys.argv)
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,9 @@
+Django>=5.0,<6.0
+djangorestframework>=3.15.0
+django-cors-headers>=4.3.0
+channels>=4.0.0
+daphne>=4.0.0
+psycopg2-binary>=2.9.0
+python-dotenv>=1.0.0
+google-auth>=2.29.0
+requests>=2.31.0