register

.gitignore

@@ -147,4 +147,7 @@ dmypy.json
 **.tfvars
 
 # Alembic / database artifcats
-**.db
+**.db
+
+# Reference repository
+ICCV2025-RealADSim-ClosedLoop_ref/

competitions/app.py

@@ -2,16 +2,17 @@ import datetime
 import os
 import threading
 import time
+from typing import List, Optional
 
 from fastapi import Depends, FastAPI, File, Form, HTTPException, Request, UploadFile
-from fastapi.responses import HTMLResponse, JSONResponse
+from fastapi.responses import HTMLResponse, JSONResponse, FileResponse
 from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
 from huggingface_hub import hf_hub_download
 from huggingface_hub.utils import disable_progress_bars
 from huggingface_hub.utils._errors import EntryNotFoundError
 from loguru import logger
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 from requests.exceptions import RequestException
 
 from competitions import __version__, utils
@@ -48,6 +49,8 @@ if REQUIREMENTS_FNAME:
     utils.uninstall_requirements(REQUIREMENTS_FNAME)
     utils.install_requirements(REQUIREMENTS_FNAME)
 
+# REQUIREMENTS_FNAME = None
+
 
 class LeaderboardRequest(BaseModel):
     lb: str
@@ -61,6 +64,25 @@ class UpdateTeamNameRequest(BaseModel):
     new_team_name: str
 
 
+class TeamMember(BaseModel):
+    """Team member data model"""
+    name: str = Field(..., max_length=50, description="Name of the team member")
+    email: str = Field(..., max_length=100, description="Email of the team member")
+    institution: str = Field(..., max_length=100, description="Institution of the team member")
+    is_student: bool = Field(..., description="Is the team member a student?")
+    majar: Optional[str] = Field(None, max_length=50, description="Major of the team member")
+    degree: Optional[str] = Field(None, description="Degree of the team member")
+    advising_professor: Optional[str] = Field(None, max_length=50, description="Advising professor of the team member")
+    grade: Optional[str] = Field(None, max_length=50, description="Grade of the team member")
+    expected_graduation_year: Optional[str] = Field(None, max_length=4, description="Expected graduation year of the team member")
+
+
+class RegisterRequest(BaseModel):
+    """Team registration request data model"""
+    team_name: str = Field(..., max_length=20, description="Name of the team")
+    team_members: List[TeamMember] = Field(min_length=1, max_length=4, description="List of team members")
+
+
 def run_job_runner():
     job_runner = JobRunner(
         competition_id=COMPETITION_ID,
@@ -122,9 +144,34 @@ async def read_form(request: Request):
 
 @app.get("/login_status", response_class=JSONResponse)
 async def use_oauth(request: Request, user_token: str = Depends(utils.user_authentication)):
+    """
+    Get user login and registration status
+    Return format:
+    {
+        "response": {
+            "is_login": bool,      # Whether user is logged in
+            "is_admin": bool,      # Whether user is admin
+            "is_registered": bool, # Whether team is registered
+            "is_white_team": bool  # Whether team is in whitelist
+        }
+    }
+    """
+    result = {
+        "is_login": False,
+        "is_admin": False,
+        "is_registered": False,
+        "is_white_team": False,
+    }
+
+    comp_org = COMPETITION_ID.split("/")[0]
     if user_token:
-        return {"response": 2}
-    return {"response": 1}
+        result["is_login"] = True
+        result["is_admin"] = utils.is_user_admin(user_token, comp_org)
+        team_info = utils.team_file_api.get_team_info(user_token)
+        result["is_registered"] = team_info is not None
+        if team_info:
+            result["is_white_team"] = team_info["id"] in utils.team_file_api.get_team_white_list()
+    return {"response": result}
 
 
 @app.get("/logout", response_class=HTMLResponse)
@@ -171,7 +218,9 @@ async def get_rules(request: Request):
 
 
 @app.get("/submission_info", response_class=JSONResponse)
-async def get_submission_info(request: Request):
+async def get_submission_info(request: Request, user_token: str = Depends(utils.user_authentication)):
+    if utils.team_file_api.get_team_info(user_token) is None:
+        return {"response": "Please register your team first."}
     competition_info = CompetitionInfo(competition_id=COMPETITION_ID, autotrain_token=HF_TOKEN)
     info = competition_info.submission_desc
     resp = {"response": info}
@@ -226,6 +275,29 @@ async def my_submissions(request: Request, user_token: str = Depends(utils.user_
                 "team_name": "",
             }
         }
+    
+    # Check team registration and whitelist status
+    team_info = utils.team_file_api.get_team_info(user_token)
+    if team_info is None:
+        return {
+            "response": {
+                "submissions": "",
+                "submission_text": SUBMISSION_TEXT.format(competition_info.submission_limit),
+                "error": "**Please register your team first.**",
+                "team_name": "",
+            }
+        }
+    
+    if team_info["id"] not in utils.team_file_api.get_team_white_list():
+        return {
+            "response": {
+                "submissions": "",
+                "submission_text": SUBMISSION_TEXT.format(competition_info.submission_limit),
+                "error": "**You are not allowed to access this resource.**",
+                "team_name": team_info["name"],
+            }
+        }
+    
     sub = Submissions(
         end_date=competition_info.end_date,
         submission_limit=competition_info.submission_limit,
@@ -253,7 +325,7 @@ async def my_submissions(request: Request, user_token: str = Depends(utils.user_
     submission_text = SUBMISSION_TEXT.format(competition_info.submission_limit)
     submission_selection_text = SUBMISSION_SELECTION_TEXT.format(competition_info.selection_limit)
 
-    team_name = utils.get_team_name(user_token, COMPETITION_ID, HF_TOKEN)
+    team_name = team_info["name"]
 
     resp = {
         "response": {
@@ -445,3 +517,47 @@ async def update_comp_info(request: Request, user_token: str = Depends(utils.use
         return {"success": False}, 500
 
     return {"success": True}
+
+
+@app.post("/register")
+def register(
+    request: RegisterRequest,
+    user_token: str = Depends(utils.user_authentication)
+):
+    """
+    Team registration endpoint
+    
+    Handle user team registration requests:
+    1. Verify user is logged in
+    2. Check if user is already registered
+    3. Create new team
+    4. Return registration result
+    """
+    if user_token is None:
+        return {"success": False, "response": "Please login."}
+
+    team_info = utils.team_file_api.get_team_info(user_token)
+    if team_info is not None:
+        return {"success": False, "response": "You have already registered your team."}
+
+    utils.team_file_api.create_team(
+        user_token,
+        request.team_name,
+        request.model_dump()
+    )
+
+    return {"success": True, "response": "Team created successfully."}
+
+
+@app.get("/register_page", response_class=HTMLResponse)
+def register_page(request: Request):
+    """
+    Display team registration page
+    """
+    if HF_TOKEN is None:
+        return HTTPException(status_code=500, detail="HF_TOKEN is not set.")
+    context = {
+        "request": request,
+        "version": __version__,
+    }
+    return templates.TemplateResponse("register_page.html", context)

competitions/templates/register_page.html

@@ -0,0 +1,258 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <title>Team Registration - JSON Editor</title>
+  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/spectre.css@latest/dist/spectre.min.css">
+  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/spectre.css@latest/dist/spectre-exp.min.css">
+  <link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.6.3/css/all.css">
+
+  <style>
+    body { 
+      font-family: Arial, sans-serif; 
+      padding: 20px; 
+      background-color: #f8f9fa;
+    }
+    .container {
+      max-width: 800px;
+      margin: 0 auto;
+      background: white;
+      padding: 2rem;
+      border-radius: 8px;
+      box-shadow: 0 2px 10px rgba(0,0,0,0.1);
+    }
+    #editor_holder { 
+      margin-bottom: 20px; 
+    }
+    .btn-group-custom {
+      display: flex;
+      justify-content: center;
+      gap: 1rem;
+      margin-top: 3rem;
+    }
+    .header {
+      text-align: center;
+      margin-bottom: 2rem;
+      color: #333;
+    }
+    .info-box {
+      background: #e3f2fd;
+      border-left: 4px solid #2196f3;
+      padding: 1rem;
+      margin-bottom: 2rem;
+      border-radius: 4px;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="header">
+      <h1>🚗 Autonomous Driving Competition Team Registration</h1>
+      <p>Please fill in the following information accurately. Inaccurate information will result in registration rejection.</p>
+    </div>
+    
+    <div class="info-box">
+      <h4>📝 Registration Instructions:</h4>
+      <ul>
+        <li>Team name cannot exceed 20 characters</li>
+        <li>Each team can have a maximum of 4 members and a minimum of 1 member</li>
+        <li>If you are a student participant, please check the "Is Student" option and fill in the relevant information</li>
+        <li>Please ensure the email address is correct, as we will contact you via email</li>
+      </ul>
+    </div>
+
+    <div id="editor_holder"></div>
+    
+    <div class="btn-group btn-group-custom">
+      <button id="submit" class="btn btn-primary btn-lg">
+        <i class="fas fa-paper-plane"></i> Submit Registration
+      </button>
+      <button id="cancel" class="btn btn-error btn-lg">
+        <i class="fas fa-times"></i> Cancel
+      </button>
+    </div>
+  </div>
+
+  <script src="https://cdn.jsdelivr.net/npm/@json-editor/json-editor@latest/dist/jsoneditor.min.js"></script>
+
+  <script>
+    const schema = {
+      "title": "Team Registration Information",
+      "type": "object",
+      "definitions": {
+        "student": {
+          "type": "object",
+          "id": "student",
+          "properties": {
+            "majar": {
+              "type": "string",
+              "title": "Major",
+              "minLength": 1,
+            },
+            "degree": {
+              "type": "string",
+              "title": "Degree",
+              "enum": ["Bachelor", "Master", "PhD"]
+            },
+            "advising_professor": {
+              "type": "string",
+              "title": "Advising Professor",
+              "minLength": 1,
+            },
+            "grade": {
+              "type": "string",
+              "title": "Grade",
+              "minLength": 1,
+            },
+            "expected_graduation_year": {
+              "type": "string",
+              "title": "Expected Graduation Year",
+              "minLength": 4,
+              "maxLength": 4,
+              "pattern": "^[0-9]{4}$"
+            }
+          }
+        }
+      },
+      "properties": {
+        "team_name": {
+          "type": "string",
+          "title": "Team Name",
+          "minLength": 1,
+          "maxLength": 20,
+          "description": "Please enter team name (no more than 20 characters)"
+        },
+        "team_members": {
+          "type": "array",
+          "title": "Team Members",
+          "minItems": 1,
+          "maxItems": 4,
+          "format": "tabs",
+          "items": {
+            "type": "object",
+            "title": "Member",
+            "properties": {
+              "name": {
+                "type": "string",
+                "title": "Name",
+                "minLength": 1,
+                "maxLength": 50
+              },
+              "email": {
+                "type": "string",
+                "title": "Email",
+                "format": "email",
+                "minLength": 1,
+                "maxLength": 100
+              },
+              "institution": {
+                "type": "string",
+                "title": "Institution",
+                "minLength": 1,
+                "maxLength": 100
+              },
+              "student_info": {
+                "title": "Is Student",
+                "oneOf": [
+                  {
+                    "title": "No",
+                    "type": "null"
+                  },
+                  {
+                    "title": "Yes",
+                    "$ref": "#/definitions/student"
+                  }
+                ]
+              }
+            }
+          }
+        }
+      }
+    };
+
+    const editor = new JSONEditor(document.getElementById('editor_holder'), {
+      schema: schema,
+      theme: 'spectre',
+      iconlib: 'fontawesome5',
+      disable_array_delete_all_rows: true,
+      disable_array_delete_last_row: true,
+      disable_collapse: true,
+      disable_edit_json: true,
+      disable_properties: true,
+      disable_array_reorder: true,
+      prompt_before_delete: false,
+      required_by_default: true,
+      array_controls_top: true,
+      remove_button_labels: true,
+      show_errors: "change",
+    });
+
+    const submitButton = document.getElementById('submit');
+    const cancelButton = document.getElementById('cancel');
+
+    submitButton.addEventListener('click', () => {
+      const errors = editor.validate();
+      editor.showValidationErrors(errors);
+      
+      if (errors.length > 0) {
+        alert('Please fix the errors in the form before submitting!');
+        return;
+      }
+      
+      const registerData = editor.getValue();
+      
+      // Convert data format to match backend API
+      registerData.team_members = registerData.team_members.map(member => {
+        return {
+          name: member.name,
+          email: member.email,
+          institution: member.institution,
+          is_student: member.student_info !== null,
+          ...member.student_info
+        };
+      });
+      
+      submitButton.textContent = "Submitting...";
+      submitButton.classList.add('disabled');
+      cancelButton.classList.add('disabled');
+      
+      fetch('/register', { 
+        method: 'POST', 
+        headers: {'Content-Type': 'application/json'}, 
+        body: JSON.stringify(registerData) 
+      })
+      .then(response => {
+        if (response.status !== 200) {
+          throw new Error('Network response was not ok');
+        }
+        return response.json();
+      })
+      .then(data => {
+        if (data.success) {
+          alert("Registration successful! Redirecting to homepage...");
+          window.location.href = "/";
+        } else {
+          alert("Registration failed: " + data.response);
+        }
+      })
+      .catch(error => {
+        console.error('Error:', error);
+        alert("An error occurred during registration. Please try again later.");
+      })
+      .finally(() => {
+        setTimeout(() => {
+          submitButton.textContent = "Submit Registration";
+          submitButton.classList.remove('disabled');
+          cancelButton.classList.remove('disabled');
+        }, 2000);
+      });
+    });
+
+    cancelButton.addEventListener('click', () => {
+      if (confirm('Are you sure you want to cancel registration?')) {
+        window.location.href = "/";
+      }
+    });
+  </script>
+</body>
+</html> 

competitions/utils.py

@@ -4,11 +4,15 @@ import os
 import shlex
 import subprocess
 import traceback
+import threading
+import uuid
+from typing import Dict, Any, List, Optional
 
 import requests
 from fastapi import Request
 from huggingface_hub import HfApi, hf_hub_download
 from loguru import logger
+from cachetools import TTLCache, cached
 
 from competitions.enums import SubmissionStatus
 from competitions.params import EvalParams
@@ -384,3 +388,189 @@ def update_team_name(user_token, new_team_name, competition_id, hf_token):
         repo_type="dataset",
     )
     return new_team_name
+
+
+class TeamAlreadyExistsError(Exception):
+    """Custom exception for when a team already exists."""
+    pass
+
+
+class TeamFileApi:
+    """
+    Team File Management API Class
+    
+    This class manages all team-related operations:
+    - Create new teams
+    - Query team information  
+    - Update team names
+    - Manage team whitelist
+    """
+    def __init__(self, hf_token: str, competition_id: str):
+        self.hf_token = hf_token
+        self.competition_id = competition_id
+        self._lock = threading.Lock()  # Thread lock to ensure thread safety for concurrent operations
+
+    def _get_team_info(self, user_id: str) -> Optional[Dict[str, Any]]:
+        """
+        Get team information by user ID
+        """
+        user_team = hf_hub_download(
+            repo_id=self.competition_id,
+            filename="user_team.json",
+            token=self.hf_token,
+            repo_type="dataset",
+        )
+
+        with open(user_team, "r", encoding="utf-8") as f:
+            user_team = json.load(f)
+
+        if user_id not in user_team:
+            return None
+
+        team_id = user_team[user_id]
+
+        team_metadata = hf_hub_download(
+            repo_id=self.competition_id,
+            filename="teams.json",
+            token=self.hf_token,
+            repo_type="dataset",
+        )
+
+        with open(team_metadata, "r", encoding="utf-8") as f:
+            team_metadata = json.load(f)
+
+        return team_metadata[team_id]
+
+    def _create_team(self, user_id: str, team_name: str, other_data: Dict[str, Any]) -> str:
+        """
+        Create new team (internal method)
+        """
+        with self._lock:  # Use lock to ensure thread safety
+            user_team = hf_hub_download(
+                repo_id=self.competition_id,
+                filename="user_team.json",
+                token=self.hf_token,
+                repo_type="dataset",
+            )
+            with open(user_team, "r", encoding="utf-8") as f:
+                user_team = json.load(f)
+
+            team_metadata = hf_hub_download(
+                repo_id=self.competition_id,
+                filename="teams.json",
+                token=self.hf_token,
+                repo_type="dataset",
+            )
+
+            with open(team_metadata, "r", encoding="utf-8") as f:
+                team_metadata = json.load(f)
+
+            # Create new team ID
+            team_id = str(uuid.uuid4())
+            user_team[user_id] = team_id
+
+            # Create team metadata
+            team_metadata[team_id] = {
+                "id": team_id,
+                "name": team_name,
+                "members": [user_id],
+                "leader": user_id,
+                "other_data": other_data,
+            }
+
+            # Upload user-team mapping file
+            user_team_json = json.dumps(user_team, indent=4)
+            user_team_json_bytes = user_team_json.encode("utf-8")
+            user_team_json_buffer = io.BytesIO(user_team_json_bytes)
+
+            # Upload team metadata file
+            team_metadata_json = json.dumps(team_metadata, indent=4)
+            team_metadata_json_bytes = team_metadata_json.encode("utf-8")
+            team_metadata_json_buffer = io.BytesIO(team_metadata_json_bytes)
+
+            api = HfApi(token=self.hf_token)
+            api.upload_file(
+                path_or_fileobj=user_team_json_buffer,
+                path_in_repo="user_team.json",
+                repo_id=self.competition_id,
+                repo_type="dataset",
+            )
+            api.upload_file(
+                path_or_fileobj=team_metadata_json_buffer,
+                path_in_repo="teams.json",
+                repo_id=self.competition_id,
+                repo_type="dataset",
+            )
+        return team_id
+    
+    def create_team(self, user_token: str, team_name: str, other_data: Dict[str, Any]) -> str:
+        """
+        Create team using user token (public interface)
+        """
+        user_info = token_information(token=user_token)
+        return self._create_team(user_info["id"], team_name, other_data)
+
+    def get_team_info(self, user_token: str) -> Optional[Dict[str, Any]]:
+        """
+        Get user's team information
+        """
+        user_info = token_information(token=user_token)
+        return self._get_team_info(user_info["id"])
+
+    def update_team_name(self, user_token, new_team_name):
+        """
+        Update team name
+        """
+        user_info = token_information(token=user_token)
+        user_id = user_info["id"]
+        team_info = self._get_team_info(user_id)
+
+        with self._lock:
+            team_metadata = hf_hub_download(
+                repo_id=self.competition_id,
+                filename="teams.json",
+                token=self.hf_token,
+                repo_type="dataset",
+            )
+            with open(team_metadata, "r", encoding="utf-8") as f:
+                team_metadata = json.load(f)
+
+            team_metadata[team_info["id"]]["name"] = new_team_name
+            team_metadata_json = json.dumps(team_metadata, indent=4)
+            team_metadata_json_bytes = team_metadata_json.encode("utf-8")
+            team_metadata_json_buffer = io.BytesIO(team_metadata_json_bytes)
+            api = HfApi(token=self.hf_token)
+            api.upload_file(
+                path_or_fileobj=team_metadata_json_buffer,
+                path_in_repo="teams.json",
+                repo_id=self.competition_id,
+                repo_type="dataset",
+            )
+        return new_team_name
+    
+    @cached(cache=TTLCache(maxsize=1, ttl=600))  # Cache for 10 minutes
+    def get_team_white_list(self) -> List[str]:
+        """
+        Get team whitelist (cached for 10 minutes)
+        """
+        try:
+            file = hf_hub_download(
+                repo_id=self.competition_id,
+                filename="team_id_whitelist.json",
+                token=self.hf_token,
+                repo_type="dataset",
+            )
+
+            with open(file, "r", encoding="utf-8") as f:
+                team_white_list = json.load(f)
+            return team_white_list
+        except:
+            # Return empty list if whitelist file doesn't exist
+            return []
+
+
+# Create global team file API instance
+team_file_api = TeamFileApi(
+    os.environ.get("HF_TOKEN", None),
+    os.environ.get("COMPETITION_ID"),
+)