update features for hugsim competition

competitions/app.py

@@ -2,9 +2,11 @@ import datetime
 import os
 import threading
 import time
+import io
+from typing import Dict, Any
 
-from fastapi import Depends, FastAPI, File, Form, HTTPException, Request, UploadFile
-from fastapi.responses import HTMLResponse, JSONResponse
+from fastapi import Depends, FastAPI, File, Form, HTTPException, Request, UploadFile, Body
+from fastapi.responses import HTMLResponse, JSONResponse, FileResponse
 from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
 from huggingface_hub import hf_hub_download
@@ -101,7 +103,7 @@ templates = Jinja2Templates(directory=templates_path)
 
 
 @app.get("/", response_class=HTMLResponse)
-async def read_form(request: Request):
+def read_form(request: Request):
     """
     This function is used to render the HTML file
     :param request:
@@ -121,14 +123,23 @@ 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)):
+def use_oauth(request: Request, user_token: str = Depends(utils.user_authentication)):
+    result = {
+        "is_login": False,
+        "is_admin": False,
+        "is_registered": 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)
+        result["is_registered"] = utils.team_file_api.get_team_info(user_token) is not None
+    return {"response": result}
 
 
 @app.get("/logout", response_class=HTMLResponse)
-async def user_logout(request: Request):
+def user_logout(request: Request):
     """Endpoint that logs out the user (e.g. delete cookie session)."""
 
     if "oauth_info" in request.session:
@@ -147,7 +158,7 @@ async def user_logout(request: Request):
 
 
 @app.get("/competition_info", response_class=JSONResponse)
-async def get_comp_info(request: Request):
+def get_comp_info(request: Request):
     competition_info = CompetitionInfo(competition_id=COMPETITION_ID, autotrain_token=HF_TOKEN)
     info = competition_info.competition_desc
     resp = {"response": info}
@@ -155,7 +166,7 @@ async def get_comp_info(request: Request):
 
 
 @app.get("/dataset_info", response_class=JSONResponse)
-async def get_dataset_info(request: Request):
+def get_dataset_info(request: Request):
     competition_info = CompetitionInfo(competition_id=COMPETITION_ID, autotrain_token=HF_TOKEN)
     info = competition_info.dataset_desc
     resp = {"response": info}
@@ -163,7 +174,7 @@ async def get_dataset_info(request: Request):
 
 
 @app.get("/rules", response_class=JSONResponse)
-async def get_rules(request: Request):
+def get_rules(request: Request):
     competition_info = CompetitionInfo(competition_id=COMPETITION_ID, autotrain_token=HF_TOKEN)
     if competition_info.rules is not None:
         return {"response": competition_info.rules}
@@ -171,7 +182,7 @@ async def get_rules(request: Request):
 
 
 @app.get("/submission_info", response_class=JSONResponse)
-async def get_submission_info(request: Request):
+def get_submission_info(request: Request):
     competition_info = CompetitionInfo(competition_id=COMPETITION_ID, autotrain_token=HF_TOKEN)
     info = competition_info.submission_desc
     resp = {"response": info}
@@ -179,7 +190,7 @@ async def get_submission_info(request: Request):
 
 
 @app.post("/leaderboard", response_class=JSONResponse)
-async def fetch_leaderboard(
+def fetch_leaderboard(
     request: Request, body: LeaderboardRequest, user_token: str = Depends(utils.user_authentication)
 ):
     lb = body.lb
@@ -215,7 +226,7 @@ async def fetch_leaderboard(
 
 
 @app.post("/my_submissions", response_class=JSONResponse)
-async def my_submissions(request: Request, user_token: str = Depends(utils.user_authentication)):
+def my_submissions(request: Request, user_token: str = Depends(utils.user_authentication)):
     competition_info = CompetitionInfo(competition_id=COMPETITION_ID, autotrain_token=HF_TOKEN)
     if user_token is None:
         return {
@@ -253,7 +264,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 = utils.team_file_api.get_team_info(user_token)["name"]
 
     resp = {
         "response": {
@@ -267,7 +278,7 @@ async def my_submissions(request: Request, user_token: str = Depends(utils.user_
 
 
 @app.post("/new_submission", response_class=JSONResponse)
-async def new_submission(
+def new_submission(
     request: Request,
     submission_file: UploadFile = File(None),
     hub_model: str = Form(...),
@@ -358,14 +369,14 @@ def update_team_name(
         return {"success": False, "error": "Team name cannot be empty."}
 
     try:
-        utils.update_team_name(user_token, new_team_name, COMPETITION_ID, HF_TOKEN)
+        utils.team_file_api.update_and_create_team_name(user_token, new_team_name)
         return {"success": True, "error": ""}
     except Exception as e:
         return {"success": False, "error": str(e)}
 
 
 @app.post("/admin/comp_info", response_class=JSONResponse)
-async def admin_comp_info(request: Request, user_token: str = Depends(utils.user_authentication)):
+def admin_comp_info(request: Request, user_token: str = Depends(utils.user_authentication)):
     comp_org = COMPETITION_ID.split("/")[0]
     user_is_admin = utils.is_user_admin(user_token, comp_org)
     if not user_is_admin:
@@ -404,7 +415,7 @@ async def admin_comp_info(request: Request, user_token: str = Depends(utils.user
 
 
 @app.post("/admin/update_comp_info", response_class=JSONResponse)
-async def update_comp_info(request: Request, user_token: str = Depends(utils.user_authentication)):
+def update_comp_info(data: Dict[str, Any] = Body(...), user_token: str = Depends(utils.user_authentication)):
     comp_org = COMPETITION_ID.split("/")[0]
     user_is_admin = utils.is_user_admin(user_token, comp_org)
     if not user_is_admin:
@@ -412,7 +423,6 @@ async def update_comp_info(request: Request, user_token: str = Depends(utils.use
 
     competition_info = CompetitionInfo(competition_id=COMPETITION_ID, autotrain_token=HF_TOKEN)
 
-    data = await request.json()
     config = data["config"]
     markdowns = data["markdowns"]
 
@@ -445,3 +455,31 @@ async def update_comp_info(request: Request, user_token: str = Depends(utils.use
         return {"success": False}, 500
 
     return {"success": True}
+
+
+@app.get("/register_template_file")
+def register_example_file():
+    file_path = os.path.join(BASE_DIR, "static", "Competition Participants Information Collection Template.xlsx")
+    return FileResponse(file_path, media_type="application/octet-stream", filename="Competition Participants Information Collection Template.xlsx")
+
+
+@app.post("/register")
+def register(
+    teamname: str = Form(...),
+    file: UploadFile = Form(...),
+    user_token: str = Depends(utils.user_authentication)
+):
+    if user_token is None:
+        return {"success": False, "response": "Please login."}
+
+    file_bytes = file.file.read()
+    file_stream = io.BytesIO(file_bytes)
+    file_stream.seek(0)
+
+    utils.team_file_api.create_team(
+        user_token,
+        teamname,
+        file_stream
+    )
+
+    return {"success": True, "response": "Team created successfully."}

competitions/runner.py

@@ -3,6 +3,7 @@ import io
 import json
 import os
 import time
+import uuid
 from dataclasses import dataclass
 
 import pandas as pd
@@ -11,7 +12,7 @@ from loguru import logger
 
 from competitions.enums import SubmissionStatus
 from competitions.info import CompetitionInfo
-from competitions.utils import run_evaluation
+from competitions.utils import run_evaluation, user_token_api
 
 
 _DOCKERFILE = """
@@ -156,12 +157,16 @@ class JobRunner:
         _readme += "colorTo: indigo\n"
         _readme += "sdk: docker\n"
         _readme += "pinned: false\n"
-        _readme += "duplicated_from: autotrain-projects/autotrain-advanced\n"
         _readme += "---\n"
         _readme = io.BytesIO(_readme.encode())
         return _readme
 
     def create_space(self, team_id, submission_id, submission_repo, space_id):
+        server_space_id = space_id + "-server"
+        client_space_id = space_id + "-client"
+        space_auth_token = uuid.uuid4().hex
+        user_token = user_token_api.get(team_id)
+
         api = HfApi(token=self.token)
         params = {
             "competition_id": self.competition_id,
@@ -180,23 +185,37 @@ class JobRunner:
             "submission_filenames": self.submission_filenames,
         }
 
-        api.add_space_secret(repo_id=space_id, key="PARAMS", value=json.dumps(params))
-
+        api.add_space_secret(repo_id=server_space_id, key="PARAMS", value=json.dumps(params))
+        api.add_space_secret(repo_id=server_space_id, key="HUGSIM_AUTH_TOKEN", value=space_auth_token)
+        api.add_space_secret(repo_id=server_space_id, key="HF_TOKEN", value=self.token)
         readme = self._create_readme(space_id.split("/")[-1])
         api.upload_file(
             path_or_fileobj=readme,
             path_in_repo="README.md",
-            repo_id=space_id,
+            repo_id=server_space_id,
             repo_type="space",
         )
-
-        _dockerfile = io.BytesIO(_DOCKERFILE.encode())
         api.upload_file(
-            path_or_fileobj=_dockerfile,
+            path_or_fileobj=io.BytesIO(_DOCKERFILE.encode()),
             path_in_repo="Dockerfile",
             repo_id=space_id,
             repo_type="space",
         )
+
+        api.add_space_secret(repo_id=client_space_id, key="HUGSIM_AUTH_TOKEN", value=space_auth_token)
+        api.snapshot_download(
+            repo_id=submission_repo,
+            repo_type="model",
+            revision="main",
+            token=user_token,
+            local_dir="/tmp/data/user_repo",
+            allow_patterns=["*"],
+        )
+        api.upload_folder(
+            repo_id=client_space_id,
+            repo_type="space",
+            folder_path="/tmp/data/user_repo",
+        )
         self._queue_submission(team_id, submission_id)
 
     def run(self):

competitions/submissions.py

@@ -6,10 +6,11 @@ from datetime import datetime
 
 import pandas as pd
 from huggingface_hub import HfApi, hf_hub_download
+from huggingface_hub.utils._errors import EntryNotFoundError
 
 from competitions.enums import SubmissionStatus
 from competitions.errors import AuthenticationError, PastDeadlineError, SubmissionError, SubmissionLimitError
-from competitions.utils import token_information
+from competitions.utils import token_information, team_file_api, user_token_api
 
 
 @dataclass
@@ -121,8 +122,7 @@ class Submissions:
         if current_datetime > self.end_date:
             raise PastDeadlineError("Competition has ended.")
 
-        user_info = self._get_user_info(user_token)
-        team_id = self._get_team_id(user_info, create_team=False)
+        team_id = team_file_api.get_team_info(user_token)["id"]
         team_submission_info = self._download_team_submissions(team_id)
 
         for sub in team_submission_info["submissions"]:
@@ -134,11 +134,14 @@ class Submissions:
         self._upload_team_submissions(team_id, team_submission_info)
 
     def _get_team_subs(self, team_id, private=False):
-        team_submissions_info = self._download_team_submissions(team_id)
+        try:
+            team_submissions_info = self._download_team_submissions(team_id)
+        except EntryNotFoundError:
+            return pd.DataFrame()
         submissions_df = pd.DataFrame(team_submissions_info["submissions"])
 
         if len(submissions_df) == 0:
-            return pd.DataFrame(), pd.DataFrame()
+            return pd.DataFrame()
 
         if not private:
             submissions_df = submissions_df.drop(columns=["private_score"])
@@ -166,46 +169,16 @@ class Submissions:
         return user_info
 
     def my_submissions(self, user_token):
-        user_info = self._get_user_info(user_token)
         current_date_time = datetime.now()
         private = False
         if current_date_time >= self.end_date:
             private = True
-        team_id = self._get_team_id(user_info, create_team=False)
+        team_id = team_file_api.get_team_info(user_token)["id"]
         if not team_id:
             return pd.DataFrame()
         return self._get_team_subs(team_id, private=private)
 
-    def _create_team(self, user_team, user_id, user_name):
-        team_metadata = hf_hub_download(
-            repo_id=self.competition_id,
-            filename="teams.json",
-            token=self.token,
-            repo_type="dataset",
-        )
-
-        with open(team_metadata, "r", encoding="utf-8") as f:
-            team_metadata = json.load(f)
-
-        # create a new team, if user is not in any team
-        team_id = str(uuid.uuid4())
-        user_team[user_id] = team_id
-
-        team_metadata[team_id] = {
-            "id": team_id,
-            "name": user_name,
-            "members": [user_id],
-            "leader": user_id,
-        }
-
-        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)
-
-        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)
-
+    def _create_submission(self, team_id: str):
         team_submission_info = {}
         team_submission_info["id"] = team_id
         team_submission_info["submissions"] = []
@@ -214,18 +187,6 @@ class Submissions:
         team_submission_info_json_buffer = io.BytesIO(team_submission_info_json_bytes)
 
         api = HfApi(token=self.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",
-        )
         api.upload_file(
             path_or_fileobj=team_submission_info_json_buffer,
             path_in_repo=f"submission_info/{team_id}.json",
@@ -234,34 +195,13 @@ class Submissions:
         )
         return team_id
 
-    def _get_team_id(self, user_info, create_team):
-        user_id = user_info["id"]
-        user_name = user_info["name"]
-        user_team = hf_hub_download(
-            repo_id=self.competition_id,
-            filename="user_team.json",
-            token=self.token,
-            repo_type="dataset",
-        )
-        with open(user_team, "r", encoding="utf-8") as f:
-            user_team = json.load(f)
-
-        if user_id in user_team:
-            return user_team[user_id]
-
-        if create_team is False:
-            return None
-
-        # if user_id is not there in user_team, create a new team
-        team_id = self._create_team(user_team, user_id, user_name)
-        return team_id
-
     def new_submission(self, user_token, uploaded_file, submission_comment):
         # verify token
         user_info = self._get_user_info(user_token)
         submission_id = str(uuid.uuid4())
         user_id = user_info["id"]
-        team_id = self._get_team_id(user_info, create_team=True)
+        team_id = team_file_api.get_team_info(user_token)["id"]
+        self._create_submission(team_id)
 
         # check if team can submit to the competition
         if self._is_submission_allowed(team_id) is False:
@@ -288,49 +228,41 @@ class Submissions:
                 submission_id=submission_id,
                 submission_comment=submission_comment,
             )
-        else:
-            # Download the submission repo and upload it to the competition repo
-            # submission_repo = snapshot_download(
-            #     repo_id=uploaded_file,
-            #     local_dir=submission_id,
-            #     token=user_token,
-            #     repo_type="model",
-            # )
-            # api = HfApi(token=self.token)
-            # competition_user = self.competition_id.split("/")[0]
-            # api.create_repo(
-            #     repo_id=f"{competition_user}/{submission_id}",
-            #     repo_type="model",
-            #     private=True,
-            # )
-            # api.upload_folder(
-            #     folder_path=submission_repo,
-            #     repo_id=f"{competition_user}/{submission_id}",
-            #     repo_type="model",
-            # )
-            # create barebones submission runner space
-            user_api = HfApi(token=user_token)
-            # submission_id is the sha of the submitted model repo + "__" + submission_id
-            submission_id = user_api.model_info(repo_id=uploaded_file).sha + "__" + submission_id
-            competition_organizer = self.competition_id.split("/")[0]
-            space_id = f"{competition_organizer}/comp-{submission_id}"
-            api = HfApi(token=self.token)
-            api.create_repo(
-                repo_id=space_id,
-                repo_type="space",
-                space_sdk="docker",
-                space_hardware=self.hardware,
-                private=True,
-            )
+            return self.submission_limit - submissions_made
 
-            api.add_space_secret(repo_id=space_id, key="USER_TOKEN", value=user_token)
-            submissions_made = self._increment_submissions(
-                team_id=team_id,
-                user_id=user_id,
-                submission_id=submission_id,
-                submission_comment=submission_comment,
-                submission_repo=uploaded_file,
-                space_id=space_id,
-            )
+        user_api = HfApi(token=user_token)
+        # submission_id is the sha of the submitted model repo + "__" + submission_id
+        submission_id = user_api.model_info(repo_id=uploaded_file).sha + "__" + submission_id
+        competition_organizer = self.competition_id.split("/")[0]
+        space_id = f"{competition_organizer}/comp-{submission_id}"
+        server_space_id = space_id + "-server"
+        client_space_id = space_id + "-client"
+
+        api = HfApi(token=self.token)
+        api.create_repo(
+            repo_id=server_space_id,
+            repo_type="space",
+            space_sdk="docker",
+            space_hardware=self.hardware,
+            private=False,
+        )
+        api.create_repo(
+            repo_id=client_space_id,
+            repo_type="space",
+            space_sdk="docker",
+            space_hardware=self.hardware,
+            private=True,
+        )
+        user_token_api.put(team_id, user_token)
+        
+        # api.add_space_secret(repo_id=space_id, key="USER_TOKEN", value=user_token)
+        submissions_made = self._increment_submissions(
+            team_id=team_id,
+            user_id=user_id,
+            submission_id=submission_id,
+            submission_comment=submission_comment,
+            submission_repo=uploaded_file,
+            space_id=space_id,
+        )
         remaining_submissions = self.submission_limit - submissions_made
         return remaining_submissions

competitions/templates/index.html

@@ -140,15 +140,16 @@
                     })
                     .then(data => {
                         const contentDiv = document.getElementById('content');
+                        const teamNameDiv = `
+                            <div class="flex items-center">
+                                <input type="text" name="team_name" id="team_name" class="mt-1 mb-1 block me-2" value="${data.response.team_name}">
+                                <button id="updateTeamNameButton" type="button" class="confirm text-white bg-green-600 hover:bg-green-800 focus:ring-4 focus:outline-none focus:ring-green-300 font-medium rounded-lg text-sm inline-flex items-center px-5 py-2.5 text-center me-2">Update Team Name</button>
+                            </div>`;
                         // console.log(data.response.submissions);
                         // contentDiv.innerHTML = marked.parse(data.response.submission_text) + data.response.submissions;
                         if (data.response.submissions && data.response.submissions.length > 0 && data.response.error.length == 0) {
                             // Start building the table HTML
-                            let tableHTML = `
-                                <div class="flex items-center">
-                                    <input type="text" name="team_name" id="team_name" class="mt-1 mb-1 block me-2" value="${data.response.team_name}">
-                                    <button id="updateTeamNameButton" type="button" class="confirm text-white bg-green-600 hover:bg-green-800 focus:ring-4 focus:outline-none focus:ring-green-300 font-medium rounded-lg text-sm inline-flex items-center px-5 py-2.5 text-center me-2">Update Team Name</button>
-                                </div>`;
+                            let tableHTML = teamNameDiv;
                             tableHTML += '<table border="1"><tr><th>Datetime</th><th>Submission ID</th><th>Public Score</th><th>Submission Comment</th><th>Selected</th><th>Status</th></tr>';
 
                             // Iterate over each submission and add it to the table
@@ -171,13 +172,13 @@
                             document.getElementById('updateSelectedSubmissionsButton').addEventListener('click', function () {
                                 updateSelectedSubmissions();
                             });
-                            document.getElementById('updateTeamNameButton').addEventListener('click', function () {
-                                updateTeamName();
-                            });
                         } else {
                             // Display message if there are no submissions
-                            contentDiv.innerHTML = marked.parse(data.response.submission_text) + marked.parse(data.response.error);
+                            contentDiv.innerHTML = teamNameDiv + marked.parse(data.response.submission_text) + marked.parse(data.response.error);
                         }
+                        document.getElementById('updateTeamNameButton').addEventListener('click', function () {
+                            updateTeamName();
+                        });
                         articleLoadingSpinner.classList.add('hidden');
                     })
                     .catch(error => {
@@ -342,12 +343,25 @@
 
         function checkOAuth() {
             var url = "/login_status";
-            makeApiRequest(url, function (response) {
-                if (response === 1) {
+            makeApiRequest(url, function ({is_login, is_admin, is_registered}) {
+                const registerRemoveStyle = ["pointer-events-none", "text-gray-400", "cursor-not-allowed"];
+                const registerNewStyle = ["ext-gray-900", "hover:bg-gray-100"]
+                if (is_login) {
+                    document.getElementById("loginButton").style.display = "none";
+                    document.getElementById("logoutButton").style.display = "block";
+                } else {
                     document.getElementById("loginButton").style.display = "block";
                     document.getElementById("logoutButton").style.display = "none";
-                } else if (response === 2) {
-                    document.getElementById("loginButton").style.display = "none";
+                }
+                if (is_admin) {
+                    document.getElementById("admin").classList.remove("hidden");
+                }
+                if (is_registered) {
+                    document.getElementById("my_submissions").classList.remove(...registerRemoveStyle);
+                    document.getElementById("my_submissions").classList.add(...registerNewStyle);
+                    document.getElementById("new_submission").classList.remove(...registerRemoveStyle);
+                    document.getElementById("new_submission").classList.add(...registerNewStyle);
+                } else {
                     document.getElementById("logoutButton").style.display = "block";
                 }
             });
@@ -459,19 +473,19 @@
                         </li>
                         <li>
                             <a href="#" id="my_submissions"
-                                class="flex items-center w-full p-2 text-gray-900 transition duration-75 rounded-lg pl-11 group hover:bg-gray-100">My
+                                class="flex items-center w-full p-2 transition duration-75 rounded-lg pl-11 group pointer-events-none text-gray-400 cursor-not-allowed">My
                                 submissions</a>
                         </li>
                         <li>
                             <a href="#" id="new_submission"
-                                class="flex items-center w-full p-2 text-gray-900 transition duration-75 rounded-lg pl-11 group hover:bg-gray-100">New
+                                class="flex items-center w-full p-2 transition duration-75 rounded-lg pl-11 group pointer-events-none text-gray-400 cursor-not-allowed">New
                                 submission</a>
                         </li>
                     </ul>
                 </li>
                 <li>
                     <a href="#" id="admin"
-                        class="flex items-center p-2 text-gray-900 rounded-lg hover:bg-gray-100 group">
+                        class="flex items-center p-2 text-gray-900 rounded-lg hover:bg-gray-100 group hidden">
                         <svg class="flex-shrink-0 w-5 h-5 text-gray-500 transition duration-75 group-hover:text-gray-900"
                             aria-hidden="true" xmlns="http://www.w3.org/2000/svg" fill="currentColor"
                             viewBox="0 0 24 24">
@@ -481,6 +495,12 @@
                         <span class="flex-1 ms-3 whitespace-nowrap">Admin</span>
                     </a>
                 </li>
+                <li id="registerButton" style="display: none;">
+                    <a href="#"
+                        class="flex justify-center items-center bg-blue-400 hover:bg-blue-600 text-white text-center font-bold py-2 px-4 rounded transition duration-200 ease-in-out">
+                        Register
+                    </a>
+                </li>
                 <li id="loginButton" style="display: none;">
                     <a href="/login/huggingface"
                         class="flex justify-center items-center bg-blue-400 hover:bg-blue-600 text-white text-center font-bold py-2 px-4 rounded transition duration-200 ease-in-out">
@@ -650,6 +670,53 @@
             </div>
         </div>
     </div>
+    <div id="register-modal" tabindex="-1"
+        class="hidden fixed inset-0 z-40 flex items-center justify-center w-full h-full bg-black bg-opacity-50">
+        <div class="relative w-full max-w-xl p-4">
+            <div class="relative bg-white rounded-lg shadow-2xl">
+                <button type="button"
+                    class="absolute top-3 right-3 text-gray-400 bg-transparent hover:bg-gray-200 hover:text-gray-900 rounded-lg text-sm w-8 h-8 inline-flex justify-center items-center"
+                    data-modal-hide="register-modal">
+                    <svg class="w-4 h-4" aria-hidden="true" xmlns="http://www.w3.org/2000/svg" fill="none"
+                        viewBox="0 0 14 14">
+                        <path stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
+                            d="m1 1 6 6m0 0 6 6M7 7l6-6M7 7l-6 6" />
+                    </svg>
+                    <span class="sr-only">Close</span>
+                </button>
+                <div class="p-6 md:p-8 text-center">
+                    <form id="registerForm" class="max-w-md mx-auto p-6 bg-white rounded-lg shadow space-y-4">
+                        <div class="grid grid-cols-3 items-center gap-4">
+                          <label for="teamname" class="text-sm font-medium text-gray-700 text-right">Team Name</label>
+                          <input type="text" id="teamname" name="teamname"
+                            class="col-span-2 px-4 py-2 border border-gray-300 rounded-md shadow-sm focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-blue-500">
+                        </div>
+                      
+                        <div class="grid grid-cols-3 items-center gap-4">
+                          <label for="reigsterFile" class="text-sm font-medium text-gray-700 text-right">Team Datas</label>
+                          <input type="file" id="reigsterFile" name="reigsterFile"
+                            class="col-span-2 text-sm text-gray-500 file:mr-4 file:py-2 file:px-4
+                                   file:rounded-md file:border-0
+                                   file:text-sm file:font-semibold
+                                   file:bg-blue-50 file:text-blue-700
+                                   hover:file:bg-blue-100">
+                        </div>
+                        <p class="mt-1 text-xs text-gray-500">
+                            Please upload a .xlsx file with the following format: <br> 
+                            <a href="/register_template_file" download class="text-blue-600 hover:underline">Download here</a>.
+                        </p>
+                        <p id="errorMessage" class="text-red-600 text-sm hidden"></p>
+                        <button type="submit"
+                          id="submitRegisterButton"
+                          class="w-full bg-blue-600 text-white py-2 px-4 rounded-md hover:bg-blue-700 transition disabled:bg-blue-800 disabled:opacity-80 disabled:cursor-not-allowed">
+                          Submit
+                        </button>
+                      </form>
+                      
+                </div>
+            </div>
+        </div>
+    </div>
     <script src="https://cdnjs.cloudflare.com/ajax/libs/flowbite/2.2.1/flowbite.min.js"></script>
     <script>
         document.addEventListener("DOMContentLoaded", function () {
@@ -948,4 +1015,60 @@
     });
 </script>
 
+
+<script>
+    document.getElementById("registerButton").addEventListener("click", function () {
+        document.getElementById("register-modal").classList.remove("hidden");
+    });
+
+    document.querySelector("[data-modal-hide='register-modal']").addEventListener("click", function () {
+        document.getElementById("register-modal").classList.add("hidden");
+    });
+
+    document.getElementById('registerForm').addEventListener('submit', function (e) {
+        e.preventDefault();
+
+        const teamname = document.getElementById('teamname').value.trim();
+        const fileInput = document.getElementById('reigsterFile');
+        const file = fileInput.files[0];
+        const errorMessage = document.getElementById('errorMessage');
+        const submitBtn = document.getElementById('submitRegisterButton');
+
+        submitBtn.disabled = true;
+        submitBtn.textContent = 'Submiting...';
+
+        errorMessage.textContent = '';
+        errorMessage.classList.add('hidden');
+
+        if (!teamname) {
+            errorMessage.textContent = 'Team name is required.';
+            errorMessage.classList.remove('hidden');
+            return;
+        }
+
+        if (!file) {
+            errorMessage.textContent = 'Please upload a file.';
+            errorMessage.classList.remove('hidden');
+            return;
+        }
+
+        const formData = new FormData();
+        formData.append('teamname', teamname);
+        formData.append('file', file);
+        fetch('/register', { method: 'POST', body: formData })
+            .then(response => response.json())
+            .then(data => {
+                if (data.success) {
+                    document.getElementById('register-modal').classList.add("hidden");
+                    window.location.reload();
+                } else {
+                    submitBtn.disabled = false;
+                    submitBtn.textContent = 'Submit';
+                    errorMessage.textContent = data.response || 'An error occurred.';
+                    errorMessage.classList.remove('hidden');
+                }
+            })
+    });
+</script>
+
 </html>

competitions/utils.py

@@ -4,11 +4,16 @@ import os
 import shlex
 import subprocess
 import traceback
+import threading
+import uuid
+import base64
+from typing import Optional, Dict, Any
 
 import requests
 from fastapi import Request
 from huggingface_hub import HfApi, hf_hub_download
 from loguru import logger
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
 
 from competitions.enums import SubmissionStatus
 from competitions.params import EvalParams
@@ -316,71 +321,203 @@ def is_user_admin(user_token, competition_organization):
     return False
 
 
-def get_team_name(user_token, competition_id, hf_token):
-    user_info = token_information(token=user_token)
-    user_id = user_info["id"]
-    user_team = hf_hub_download(
-        repo_id=competition_id,
-        filename="user_team.json",
-        token=hf_token,
-        repo_type="dataset",
-    )
-    with open(user_team, "r", encoding="utf-8") as f:
-        user_team = json.load(f)
+class TeamAlreadyExistsError(Exception):
+    """Custom exception for when a team already exists."""
+    pass
 
-    if user_id not in user_team:
-        return None
+class TeamFileApi:
+    def __init__(self, hf_token: str, competition_id: str):
+        self.hf_token = hf_token
+        self.competition_id = competition_id
+        self._lock = threading.Lock()
 
-    team_id = user_team[user_id]
+    def _get_team_info(self, user_id: str) -> Optional[Dict[str, Any]]:
+        user_team = hf_hub_download(
+            repo_id=self.competition_id,
+            filename="user_team.json",
+            token=self.hf_token,
+            repo_type="dataset",
+        )
 
-    team_metadata = hf_hub_download(
-        repo_id=competition_id,
-        filename="teams.json",
-        token=hf_token,
-        repo_type="dataset",
-    )
-    with open(team_metadata, "r", encoding="utf-8") as f:
-        team_metadata = json.load(f)
+        with open(user_team, "r", encoding="utf-8") as f:
+            user_team = json.load(f)
 
-    team_name = team_metadata[team_id]["name"]
-    return team_name
+        if user_id not in user_team:
+            return None
 
+        team_id = user_team[user_id]
 
-def update_team_name(user_token, new_team_name, competition_id, hf_token):
-    user_info = token_information(token=user_token)
-    user_id = user_info["id"]
-    user_team = hf_hub_download(
-        repo_id=competition_id,
-        filename="user_team.json",
-        token=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",
+        )
 
-    if user_id not in user_team:
-        raise Exception("User is not part of a team")
+        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, team_file: Optional[io.BytesIO]) -> str:
+        with self._lock:
+            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 a new team, if user is not in any team
+            team_id = str(uuid.uuid4())
+            user_team[user_id] = team_id
+
+            team_metadata[team_id] = {
+                "id": team_id,
+                "name": team_name,
+                "members": [user_id],
+                "leader": user_id,
+            }
+
+            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)
+
+            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",
+            )
+
+            if team_file is not None:
+                resp = api.upload_file(
+                    path_or_fileobj=team_file,
+                    path_in_repo=f"team_datas/{team_id}.xlsx",
+                    repo_id=self.competition_id,
+                    repo_type="dataset",
+                )
+        return team_id
+    
+    def create_team(self, user_token: str, team_name: str, team_file: io.BytesIO) -> str:
+        user_info = token_information(token=user_token)
+        return self._create_team(user_info["id"], team_name, team_file)
+
+    def get_team_info(self, user_token: str) -> Optional[Dict[str, Any]]:
+        user_info = token_information(token=user_token)
+        return self._get_team_info(user_info["id"])
+
+    def update_and_create_team_name(self, user_token, new_team_name):
+        user_info = token_information(token=user_token)
+        user_id = user_info["id"]
+        team_info = self._get_team_info(user_id)
+        if team_info is None:
+            self._create_team(user_id, new_team_name)
+            return new_team_name
+
+        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
+
+
+team_file_api = TeamFileApi(
+    os.environ.get("HF_TOKEN", None),
+    os.environ.get("COMPETITION_ID"),
+)
+
+
+class UserTokenApi:
+    def __init__(self, hf_token: str, key_base64: str, competition_id: str):
+        self.hf_token = hf_token
+        self.key = base64.b64decode(key_base64)
+        self.competition_id = competition_id
+    
+    def _encrypt(self, text: str) -> str:
+        aesgcm = AESGCM(self.key)
+        nonce = os.urandom(12)
+        encrypted_data = aesgcm.encrypt(nonce, text.encode(), None)
+        return base64.b64encode(nonce + encrypted_data).decode()
+
+    def _decrypt(self, encrypted_text: str) -> str:
+        aesgcm = AESGCM(self.key)
+        data = base64.b64decode(encrypted_text)
+        nonce = data[:12]
+        ciphertext = data[12:]
+        plaintext = aesgcm.decrypt(nonce, ciphertext, None)
+        return plaintext.decode()
+    
+    def put(self, team_id: str, user_token: str):
+        encrypted_token = self._encrypt(user_token)
+        api = HfApi(token=self.hf_token)
+        api.upload_file(
+            path_or_fileobj=io.BytesIO(encrypted_token.encode()),
+            path_in_repo=f"team_user_tokens/{team_id}",
+            repo_id=self.competition_id,
+            repo_type="dataset",
+        )
 
-    team_id = user_team[user_id]
+    def get(self, team_id: str) -> Optional[str]:
+        try:
+            user_token = hf_hub_download(
+                repo_id=self.competition_id,
+                filename=f"team_user_tokens/{team_id}",
+                token=self.hf_token,
+                repo_type="dataset",
+            )
+        except Exception as e:
+            logger.error(f"Failed to download user token - {e}")
+            return None
 
-    team_metadata = hf_hub_download(
-        repo_id=competition_id,
-        filename="teams.json",
-        token=hf_token,
-        repo_type="dataset",
-    )
-    with open(team_metadata, "r", encoding="utf-8") as f:
-        team_metadata = json.load(f)
-
-    team_metadata[team_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=hf_token)
-    api.upload_file(
-        path_or_fileobj=team_metadata_json_buffer,
-        path_in_repo="teams.json",
-        repo_id=competition_id,
-        repo_type="dataset",
-    )
-    return new_team_name
+        with open(user_token, "r", encoding="utf-8") as f:
+            encrypted_token = f.read()
+
+        return self._decrypt(encrypted_token)
+
+
+user_token_api = UserTokenApi(
+    os.environ.get("HF_TOKEN", None),
+    os.environ.get("USER_TOKEN_KEY_BASE64"),
+    os.environ.get("COMPETITION_ID")
+)