generalize application for any course

.gitignore

@@ -0,0 +1,5 @@
+.ruff_cache
+.venv
+__pycache__
+uv.lock
+.python-version

app.py

@@ -1,435 +1,181 @@
-import gradio as gr
-from huggingface_hub import HfApi, hf_hub_download, Repository
-from huggingface_hub.repocard import metadata_load
-
-from PIL import Image, ImageDraw, ImageFont
-
-from datetime import date
-import time  
-
 import os
-import pandas as pd
-
-from utils import *
-
-api = HfApi()
+import requests
+from io import BytesIO
+from datetime import date
 
-DATASET_REPO_URL = "https://huggingface.co/datasets/huggingface-projects/Deep-RL-Course-Certification"
-CERTIFIED_USERS_FILENAME = "certified_users.csv"
-CERTIFIED_USERS_DIR = "certified_users"
+import gradio as gr
+from PIL import Image, ImageDraw, ImageFont
+from huggingface_hub import whoami
 
-HF_TOKEN = os.environ.get("HF_TOKEN")
+from criteria import check_certification as check_certification_criteria
+from org import join_finishers_org
 
-repo = Repository(
-    local_dir=CERTIFIED_USERS_DIR, clone_from=DATASET_REPO_URL, use_auth_token=HF_TOKEN
-)
 
-def get_user_models(hf_username, env_tag, lib_tag):
-    """
-    List the Reinforcement Learning models
-    from user given environment and lib
-    :param hf_username: User HF username
-    :param env_tag: Environment tag
-    :param lib_tag: Library tag
-    """
-    api = HfApi()
-    models = api.list_models(author=hf_username, filter=["reinforcement-learning", env_tag, lib_tag])
-
-    user_model_ids = [x.modelId for x in models]
-    return user_model_ids
-
-
-def get_user_sf_models(hf_username, env_tag, lib_tag):
-    models_sf = []
-    models = api.list_models(author=hf_username, filter=["reinforcement-learning", lib_tag])
-
-    user_model_ids = [x.modelId for x in models]
-
-    for model in user_model_ids:
-        meta = get_metadata(model)
-        if meta is None:
-            continue
-        result = meta["model-index"][0]["results"][0]["dataset"]["name"]
-        if result == env_tag:
-            models_sf.append(model)
-            
-    return models_sf
-
-
-def get_metadata(model_id):
-  """
-  Get model metadata (contains evaluation data)
-  :param model_id
-  """
-  try:
-    readme_path = hf_hub_download(model_id, filename="README.md")
-    return metadata_load(readme_path)
-  except requests.exceptions.HTTPError:
-    # 404 README.md not found
-    return None
-
-
-def parse_metrics_accuracy(meta):
-  """
-  Get model results and parse it
-  :param meta: model metadata
-  """
-  if "model-index" not in meta:
-    return None
-  result = meta["model-index"][0]["results"]
-  metrics = result[0]["metrics"]
-  accuracy = metrics[0]["value"]
-  
-  return accuracy
-
-
-def parse_rewards(accuracy):
-  """
-  Parse mean_reward and std_reward
-  :param accuracy: model results
-  """
-  default_std = -1000
-  default_reward= -1000
-  if accuracy !=  None:
-      accuracy = str(accuracy)
-      parsed =  accuracy.split(' +/- ')
-      if len(parsed)>1:
-          mean_reward = float(parsed[0])
-          std_reward =  float(parsed[1])
-      elif len(parsed)==1: #only mean reward   
-          mean_reward = float(parsed[0])
-          std_reward =  float(0)
-      else: 
-          mean_reward = float(default_std)
-          std_reward = float(default_reward)
-  else:
-      mean_reward = float(default_std)
-      std_reward = float(default_reward)
-  
-  return mean_reward, std_reward
-
-def calculate_best_result(user_model_ids):
-  """
-  Calculate the best results of a unit
-  best_result = mean_reward - std_reward
-  :param user_model_ids: RL models of a user
-  """
-  best_result = -1000
-  best_model_id = ""
-  for model in user_model_ids:
-    meta = get_metadata(model)
-    if meta is None:
-      continue
-    accuracy = parse_metrics_accuracy(meta)
-    mean_reward, std_reward = parse_rewards(accuracy)
-    result = mean_reward - std_reward
-    if result > best_result:
-      best_result = result
-      best_model_id = model
-      
-  return best_result, best_model_id
-
-def check_if_passed(model):
-  """
-  Check if result >= baseline
-  to know if you pass
-  :param model: user model
-  """
-  if model["best_result"] >= model["min_result"]:
-    model["passed_"] = True
-
-
-def certification(hf_username, first_name, last_name):
-  results_certification = [
-      {
-          "unit": "Unit 1",
-          "env": "LunarLander-v2",
-          "library": "stable-baselines3",
-          "min_result": 200,
-          "best_result": 0,
-          "best_model_id": "",
-          "passed_": False
-      },
-  {
-          "unit": "Unit 2",
-          "env": "Taxi-v3",
-          "library": "q-learning",
-          "min_result": 4,
-          "best_result": 0,
-          "best_model_id": "",
-          "passed_": False
-  },
-  {
-          "unit": "Unit 3",
-          "env": "SpaceInvadersNoFrameskip-v4",
-          "library": "stable-baselines3",
-          "min_result": 200,
-          "best_result": 0,
-          "best_model_id": "",
-          "passed_": False
-  },
-  {
-          "unit": "Unit 4",
-          "env": "CartPole-v1",
-          "library": "reinforce",
-          "min_result": 350,
-          "best_result": 0,
-          "best_model_id": "",
-          "passed_": False
-  },
-    {
-          "unit": "Unit 4",
-          "env": "Pixelcopter-PLE-v0",
-          "library": "reinforce",
-          "min_result": 5,
-          "best_result": 0,
-          "best_model_id": "",
-          "passed_": False
-    },
-      {
-          "unit": "Unit 5",
-          "env": "ML-Agents-SnowballTarget",
-          "library": "ml-agents",
-          "min_result": -100,
-          "best_result": 0,
-          "best_model_id": "",
-          "passed_": False
-    },
-      {
-          "unit": "Unit 5",
-          "env": "ML-Agents-Pyramids",
-          "library": "ml-agents",
-          "min_result": -100,
-          "best_result": 0,
-          "best_model_id": "",
-          "passed_": False
-    },
-      {
-          "unit": "Unit 6",
-          "env": "PandaReachDense",
-          "library": "stable-baselines3",
-          "min_result": -3.5,
-          "best_result": 0,
-          "best_model_id": "",
-          "passed_": False
-    },
-      {
-          "unit": "Unit 7",
-          "env": "ML-Agents-SoccerTwos",
-          "library": "ml-agents",
-          "min_result": -100,
-          "best_result": 0,
-          "best_model_id": "",
-          "passed_": False
-    },
-      {
-          "unit": "Unit 8 PI",
-          "env": "LunarLander-v2",
-          "library": "deep-rl-course",
-          "min_result": -500,
-          "best_result": 0,
-          "best_model_id": "",
-          "passed_": False
-    },
-      {
-          "unit": "Unit 8 PII",
-          "env": "doom_health_gathering_supreme",
-          "library": "sample-factory",
-          "min_result": 5,
-          "best_result": 0,
-          "best_model_id": "",
-          "passed_": False
-    },
-  ] 
-  for unit in results_certification:
-    if unit["unit"] == "Unit 6":
-      # Since Unit 6 can use PandaReachDense-v2 or v3
-      user_models = get_user_models(hf_username, "PandaReachDense-v3", unit["library"])
-      if len(user_models) == 0:
-        print("Empty")
-        user_models = get_user_models(hf_username, "PandaReachDense-v2", unit["library"])
-    elif unit["unit"] != "Unit 8 PII":
-      # Get user model
-      user_models = get_user_models(hf_username, unit['env'], unit['library'])
-      # For sample factory vizdoom we don't have env tag for now
-    else: 
-      user_models = get_user_sf_models(hf_username, unit['env'], unit['library'])
-    
-    # Calculate the best result and get the best_model_id
-    best_result, best_model_id = calculate_best_result(user_models)
-
-    # Save best_result and best_model_id
-    unit["best_result"] = best_result
-    unit["best_model_id"] = make_clickable_model(best_model_id)
-
-    # Based on best_result do we pass the unit?
-    check_if_passed(unit)
-    unit["passed"] = pass_emoji(unit["passed_"])
-    
-  print(results_certification)
- 
-  df1 = pd.DataFrame(results_certification)
-
-  df = df1[['passed', 'unit', 'env', 'min_result', 'best_result', 'best_model_id']]
-
-  certificate, message, pdf, pass_ = verify_certification(results_certification, hf_username, first_name, last_name)
-  print("MESSAGE", message)
-
-  if pass_:
-    visible = True
-  else:
-    visible = False
-
-  
-  return message, pdf, certificate, df, output_row.update(visible=visible) 
-
-"""
-Verify that the user pass.
-If yes:
-- Generate the certification
-- Send an email
-- Print the certification
-
-If no:
-- Explain why the user didn't pass yet
-"""
-def verify_certification(df, hf_username, first_name, last_name):
-  # Check that we pass
-  model_pass_nb = 0
-  pass_percentage = 0
-  pass_ = False
-
-  for unit in df:
-    if unit["passed_"] is True:
-      model_pass_nb += 1
-  
-  pass_percentage = (model_pass_nb/11) * 100 
-  print("pass_percentage", pass_percentage)
-  
-  if pass_percentage == 100:
-    pass_ = True
-    # Generate a certificate of excellence
-    certificate, pdf = generate_certificate("./certificate_models/certificate-excellence.png", first_name, last_name)
-
-    # Add this user to our database
-    add_certified_user(hf_username, first_name, last_name, pass_percentage)
-    
-    # Add a message
-    message = """
-    Congratulations, you successfully completed the Hugging Face Deep Reinforcement Learning Course 🎉! \n 
-    Since you pass 100% of the hands-on you get a Certificate of Excellence 🎓. \n
-    You can download your certificate below ⬇️ \n
-    Don't hesitate to share your certificate image below on Twitter and Linkedin (you can tag me @ThomasSimonini and @huggingface) 🤗
-    """
+def download_profile_picture(profile_url: str):
+    """Download profile picture from URL."""
+    response = requests.get(profile_url)
+    return Image.open(BytesIO(response.content))
 
-  elif pass_percentage < 100 and pass_percentage >= 80:
-    pass_ = True
-    # Certificate of completion
-    certificate, pdf = generate_certificate("./certificate_models/certificate-completion.png", first_name, last_name)
-
-    # Add this user to our database
-    add_certified_user(hf_username, first_name, last_name, pass_percentage)
-
-    # Add a message
-    message = """
-    Congratulations, you successfully completed the Hugging Face Deep Reinforcement Learning Course 🎉! \n 
-    Since you pass 80% of the hands-on you get a Certificate of Completion 🎓. \n 
-    You can download your certificate below ⬇️ \n
-    Don't hesitate to share your certificate image below on Twitter and Linkedin (you can tag me @ThomasSimonini and @huggingface) 🤗 \n
-    You can try to get a Certificate of Excellence if you pass 100% of the hands-on, don't hesitate to check which unit you didn't pass and update these models.
-    """
-  
-  else:
-    # Not pass yet
-    certificate = Image.new("RGB", (100, 100), (255, 255, 255))
-    pdf = "./fail.pdf"
-          
-    # Add a message
-    message = """
-    You didn't pass the minimum of 80% of the hands-on to get a certificate of completion. But don't be discouraged! \n 
-    Check below which units you need to do again to get your certificate 💪
-    """
-  print("return certificate")
-  return certificate, message, pdf, pass_
-    
 
-def generate_certificate(certificate_model, first_name, last_name):
-    im = Image.open(certificate_model)
+def generate_certificate(
+    certificate_path: str, first_name: str, last_name: str, profile_url: str
+):
+    """Generate certificate image and PDF."""
+    im = Image.open(certificate_path)
     d = ImageDraw.Draw(im)
 
     name_font = ImageFont.truetype("Quattrocento-Regular.ttf", 100)
     date_font = ImageFont.truetype("Quattrocento-Regular.ttf", 48)
-    
-    name = str(first_name) + " " + str(last_name)
-    print("NAME", name)
-    
-    # Debug line name
-    #d.line(((200, 740), (1800, 740)), "gray")
-    #d.line(((1000, 0), (1000, 1400)), "gray")
-    
-    # Name
+
+    name = f"{first_name} {last_name}"
+
+    # Capitalize first letter of each name
+    name = name.title()
+
+    # Add name
     d.text((1000, 740), name, fill="black", anchor="mm", font=name_font)
 
-    # Debug line date
-    #d.line(((1500, 0), (1500, 1400)), "gray")
+    # Add profile picture just below the name
+    profile_img = download_profile_picture(profile_url)
+    profile_img = profile_img.resize((100, 100))
+    im.paste(im=profile_img, box=(350, 700))
 
-    # Date of certification
+    # Add date
     d.text((1480, 1170), str(date.today()), fill="black", anchor="mm", font=date_font)
 
-
-    pdf = im.convert('RGB')
-    pdf.save('certificate.pdf')
+    # Save PDF
+    pdf = im.convert("RGB")
+    pdf.save("certificate.pdf")
 
     return im, "./certificate.pdf"
 
 
+def get_user_info(oauth_token):
+    """Get user info from HF token."""
+    if oauth_token is None:
+        return None, None, None, None
+    try:
+        user_info = whoami(oauth_token.token)
+        username = user_info["name"]
+        name_parts = user_info["fullname"].split(" ", 1)
+        first_name = name_parts[0]
+        last_name = name_parts[1] if len(name_parts) > 1 else ""
+        profile_url = user_info["avatarUrl"]
+        return username, first_name, last_name, profile_url
+    except:
+        return None, None, None, None
+
+
+def create_linkedin_button(username: str) -> str:
+    """Create LinkedIn 'Add to Profile' button HTML."""
+    current_year = date.today().year
+    current_month = date.today().month
+
+    # URL encode the certificate URL
+    cert_url = "https://huggingface.co/agents-course-finishers"
+
+    linkedin_params = {
+        "startTask": "CERTIFICATION_NAME",
+        "name": "Hugging Face Course Certificate",
+        # "organizationId": "40479",  # Hugging Face's LinkedIn Organization ID
+        "organizationName": "Hugging Face",
+        "issueYear": str(current_year),
+        "issueMonth": str(current_month),
+        "certUrl": cert_url,
+        "certId": username,  # Using username as cert ID
+    }
+
+    # Build the LinkedIn button URL
+    base_url = "https://www.linkedin.com/profile/add?"
+    params = "&".join(
+        f"{k}={requests.utils.quote(v)}" for k, v in linkedin_params.items()
+    )
+    button_url = base_url + params
+
+    return f"""
+        <a href="{button_url}" target="_blank" style="display: block; margin-top: 20px; text-align: center;">
+            <img src="https://download.linkedin.com/desktop/add2profile/buttons/en_US.png" 
+                 alt="LinkedIn Add to Profile button">
+        </a>
+    """
+
 
-def add_certified_user(hf_username, first_name, last_name, pass_percentage):
-  """
-  Add the certified user to the database
-  """
-  print("ADD CERTIFIED USER")
-  repo.git_pull()
-  history = pd.read_csv(os.path.join(CERTIFIED_USERS_DIR, CERTIFIED_USERS_FILENAME))
-
-  # Check if this hf_username is already in our dataset:
-  check = history.loc[history['hf_username'] == hf_username]
-  if not check.empty:
-    history = history.drop(labels=check.index[0], axis=0)
-  
-  new_row = pd.DataFrame({'hf_username': hf_username, 'first_name': first_name, 'last_name': last_name, 'pass_percentage': pass_percentage, 'datetime': time.time()}, index=[0])
-  history = pd.concat([new_row, history[:]]).reset_index(drop=True)
-    
-  history.to_csv(os.path.join(CERTIFIED_USERS_DIR, CERTIFIED_USERS_FILENAME), index=False)
-  repo.push_to_hub(commit_message="Update certified users list")
-
-
-with gr.Blocks() as demo:
-    gr.Markdown(f"""
-    # Get your Deep Reinforcement Learning Certificate 🎓
-    The certification process is completely free:
-
-    - To get a *certificate of completion*: you need to **pass 80% of the assignments**.
-    - To get a *certificate of honors*: you need to **pass 100% of the assignments**.
-
-    There's **no deadlines, the course is self-paced**.
-
-    For more information about the certification process [check this](https://huggingface.co/deep-rl-course/communication/certification)
-
-    Don’t hesitate to share your certificate on Twitter (tag me @ThomasSimonini and @huggingface) and on Linkedin.
-    """)
-    
-    hf_username = gr.Textbox(placeholder="ThomasSimonini", label="Your Hugging Face Username (case sensitive)")
-    first_name = gr.Textbox(placeholder="Jane", label="Your First Name")
-    last_name = gr.Textbox(placeholder="Doe", label="Your Last Name")
-    #email = gr.Textbox(placeholder="jane.[email protected]", label="Your Email (to receive your certificate)")
-    check_progress_button = gr.Button(value="Check if I pass")
-    output_text = gr.components.Textbox()
-    with gr.Row(visible=True) as output_row:
-        output_pdf = gr.File()
-        output_img = gr.components.Image(type="pil")
-    output_dataframe = gr.components.Dataframe(headers=["Pass?", "Unit", "Environment", "Baseline", "Your best result", "Your best model id"], datatype=["markdown", "markdown", "markdown", "number", "number", "markdown", "bool"]) #value= certification(hf_username, first_name, last_name), 
-    check_progress_button.click(fn=certification, inputs=[hf_username, first_name, last_name], outputs=[output_text, output_pdf, output_img, output_dataframe, output_row])#[output1, output2])
-
-    
-demo.launch(debug=True)
+def check_certification(token: gr.OAuthToken | None):
+    """Check certification status for logged-in user."""
+    if token is None:
+        gr.Warning("Please log in to Hugging Face before checking certification!")
+        return None, None, None, gr.Row.update(visible=False)
+
+    username, first_name, last_name, profile_url = get_user_info(token)
+    if not username:
+        return (
+            "Please login with your Hugging Face account to check certification status",
+            None,
+            None,
+            gr.Row.update(visible=False),
+        )
+
+    # Check certification criteria
+    result = check_certification_criteria(username)
+
+    # Generate certificate if passed
+    if result.passed and result.certificate_path:
+        certificate_img, pdf_path = generate_certificate(
+            certificate_path=result.certificate_path,
+            first_name=first_name,
+            last_name=last_name,
+            profile_url=profile_url,
+        )
+
+        # Add LinkedIn button for passed certificates
+        linkedin_button = create_linkedin_button(username)
+        result_message = f"{result.message}\n\n{linkedin_button}"
+    else:
+        certificate_img = None
+        pdf_path = None
+        result_message = result.message
+
+    return (
+        gr.update(visible=True, value=result_message, label="Grade"),
+        gr.update(visible=result.passed, value=pdf_path, label="Download Certificate"),
+        gr.update(visible=result.passed, value=certificate_img, label="Certificate"),
+    )
+
+
+def create_gradio_interface():
+    """Create Gradio web interface with OAuth login."""
+    with gr.Blocks() as demo:
+        gr.Markdown("""
+        # Get your Hugging Face Course Certificate 🎓
+        The certification process is completely free.
+        
+        To receive your certificate, you need to **pass 80% of the quiz**.
+
+        There's **no deadlines, the course is self-paced**.
+
+        Don't hesitate to share your certificate on Twitter 
+        (tag @huggingface) and on Linkedin.
+        """)
+
+        # Add login button
+        gr.LoginButton()
+
+        check_progress_button = gr.Button(value="Check My Progress")
+
+        output_text = gr.Markdown(visible=False, sanitize_html=False)
+        output_img = gr.Image(type="pil", visible=False)
+        output_pdf = gr.File(visible=False)
+
+        check_progress_button.click(
+            fn=check_certification,
+            outputs=[output_text, output_pdf, output_img],
+        ).then(
+            fn=join_finishers_org,
+        )
+
+    return demo
+
+
+if __name__ == "__main__":
+    demo = create_gradio_interface()
+    demo.launch(debug=True)

criteria.py

@@ -0,0 +1,200 @@
+import os
+from typing import Dict, List, Optional, NamedTuple, Tuple
+from datetime import datetime
+
+from datasets import load_dataset
+from huggingface_hub import HfApi
+
+# Environment variables and constants
+EXAM_DATASET_ID = os.getenv(
+    "EXAM_DATASET_ID", "agents-course/unit_1_quiz_student_responses"
+)
+CERTIFICATE_MODELS_DIR = os.getenv("CERTIFICATE_MODELS_DIR", "./certificate_models")
+CERTIFICATE_PATH = os.path.join(CERTIFICATE_MODELS_DIR, "certificate.png")
+
+PASSING_THRESHOLD = float(os.getenv("PASSING_THRESHOLD", "0.8"))  # 80%
+MIN_QUESTIONS = int(os.getenv("MIN_QUESTIONS", "1"))
+
+
+class CertificateResult(NamedTuple):
+    """Stores the result of a certificate check"""
+
+    message: str
+    certificate_path: Optional[str]
+    pass_percentage: float
+    passed: bool
+    results_df: Optional[object] = None
+
+
+def get_user_results(username: str) -> List[Dict]:
+    """
+    Get user's quiz results from the dataset.
+
+    Args:
+        username: The Hugging Face username to check
+
+    Returns:
+        List of user's quiz results
+    """
+    try:
+        ds = load_dataset(EXAM_DATASET_ID, split="train")
+
+        # Filter for this user's results
+        user_results = ds.filter(lambda x: x["username"] == username)
+
+        results = user_results.to_list()
+        print(f"Found {len(results)} results for user {username}")
+        return results
+
+    except Exception as e:
+        print(f"Error in get_user_results: {str(e)}")
+        raise
+
+
+def calculate_pass_percentage(results: List[Dict]) -> Tuple[float, int]:
+    """
+    Calculate the user's pass percentage and number of questions from their results.
+
+    The dataset structure has:
+    - is_correct: bool indicating if answer was correct
+    - grade: float64 indicating overall grade
+    - datetime: string of attempt timestamp
+
+    Args:
+        results: List of quiz results
+
+    Returns:
+        Tuple of (highest grade achieved, number of questions answered)
+    """
+    try:
+        if not results:
+            return 0.0, 0
+
+        # Group results by datetime to get distinct attempts
+        attempts = {}
+        for result in results:
+            timestamp = result["datetime"]
+            if timestamp not in attempts:
+                attempts[timestamp] = {
+                    "correct": 0,
+                    "total": 0,
+                    "grade": result.get("grade", 0.0),
+                }
+
+            attempts[timestamp]["total"] += 1
+            if result["is_correct"]:
+                attempts[timestamp]["correct"] += 1
+
+        # Find the best attempt
+        best_attempt = max(
+            attempts.values(),
+            key=lambda x: x["grade"]
+            if x["grade"] is not None
+            else (x["correct"] / x["total"] if x["total"] > 0 else 0),
+        )
+
+        # If grade is available, use it; otherwise calculate from correct/total
+        if best_attempt["grade"] is not None and best_attempt["grade"] > 0:
+            pass_percentage = float(best_attempt["grade"])
+        else:
+            pass_percentage = (
+                best_attempt["correct"] / best_attempt["total"]
+                if best_attempt["total"] > 0
+                else 0.0
+            )
+
+        return pass_percentage, best_attempt["total"]
+
+    except Exception as e:
+        print(f"Error in calculate_pass_percentage: {str(e)}")
+        raise
+
+
+def has_passed(pass_percentage: float, num_questions: int) -> bool:
+    """
+    Check if user has passed based on percentage and minimum questions.
+
+    Args:
+        pass_percentage: User's highest quiz score
+        num_questions: Number of questions answered
+
+    Returns:
+        Boolean indicating if user passed
+    """
+    return pass_percentage >= PASSING_THRESHOLD and num_questions >= MIN_QUESTIONS
+
+
+def get_certificate_result(
+    pass_percentage: float, num_questions: int
+) -> CertificateResult:
+    """
+    Determine if user passed and create appropriate message.
+
+    Args:
+        pass_percentage: User's highest quiz score
+        num_questions: Number of questions answered
+
+    Returns:
+        CertificateResult with pass status and details
+    """
+    passed = has_passed(pass_percentage, num_questions)
+
+    if passed:
+        return CertificateResult(
+            message="""
+            Congratulations, you successfully completed the course! 🎉 \n
+            You can download your certificate below ⬇️ \n    
+            You are now an <a href="https://huggingface.co/agents-course-finishers">Agent Course Finisher</a>!
+            """,
+            certificate_path=CERTIFICATE_PATH,
+            pass_percentage=pass_percentage,
+            passed=True,
+        )
+    else:
+        return CertificateResult(
+            message="""
+            You haven't completed all the requirements yet. \n
+            Keep trying! 💪
+            """,
+            certificate_path=None,
+            pass_percentage=pass_percentage,
+            passed=False,
+        )
+
+
+def check_certification(username: str) -> CertificateResult:
+    """
+    Check if a user has completed the certification requirements.
+
+    Args:
+        username: The Hugging Face username to check
+
+    Returns:
+        CertificateResult containing pass status and details
+    """
+    try:
+        # Get user's quiz results
+        results = get_user_results(username)
+        if not results:
+            return CertificateResult(
+                message="No quiz results found. Please complete the quiz first.",
+                certificate_path=None,
+                pass_percentage=0.0,
+                passed=False,
+            )
+
+        # Calculate pass percentage and get appropriate certificate result
+        pass_percentage, num_questions = calculate_pass_percentage(results)
+        return get_certificate_result(pass_percentage, num_questions)
+
+    except Exception as e:
+        error_msg = """
+        There was an error checking your certification status.
+        Please try again later or contact support if the issue persists.
+        """
+        return CertificateResult(
+            message=error_msg,
+            certificate_path=None,
+            pass_percentage=0.0,
+            passed=False,
+        )

org.py

@@ -0,0 +1,38 @@
+import os
+import requests
+
+# Remove unused import
+# Break long URL into multiple lines using parentheses
+JOIN_ORG_URL = (
+    os.getenv("JOIN_ORG_URL")
+    or "https://huggingface.co/organizations/agents-course-finishers/share/"
+    "XmxAybhNLOogLeBzZnBUVbazpTlDETqFId"
+)
+
+
+def join_finishers_org():
+    """Join the finishers organization using the provided auth cookie.
+
+    Args:
+        user_auth_cookie (str): User's authentication cookie
+
+    Returns:
+        bool: True if join was successful, False otherwise
+    """
+
+    # If you need to include a cookie for authentication, you can do so here
+    # Otherwise, you can leave the headers empty
+    headers = {
+        # "Cookie": "session=abc123def456ghi789jkl012mno345pqr678"  # Uncomment and add your cookie if needed
+    }
+
+    # Send the POST request
+    response = requests.post(url=JOIN_ORG_URL, headers=headers)
+
+    # Check the response status code
+    if response.status_code == 200:
+        print("Successfully joined the organization!")
+    else:
+        print(f"Failed to join the organization. Status code: {response.status_code}")
+
+

pyproject.toml

@@ -0,0 +1,13 @@
+[project]
+name = "certification-app"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "datasets>=3.2.0",
+    "gradio[oauth]==5.15.0",
+    "huggingface-hub>=0.28.1",
+    "pandas>=2.2.3",
+    "pillow>=11.1.0",
+]

utils.py

@@ -1,16 +0,0 @@
-# Based on Omar Sanseviero work
-# Make model clickable link
-def make_clickable_model(model_name):
-    # remove user from model name
-    model_name_show = ' '.join(model_name.split('/')[1:])
-
-    link = "https://huggingface.co/" + model_name
-    return f'<a target="_blank" href="{link}">{model_name_show}</a>'
-
-def pass_emoji(passed):
-    print("PASSED", passed)
-    if passed is True:
-        passed = "✅"
-    else:
-        passed = "❌"
-    return passed