Spaces:
Runtime error
Runtime error
| import gradio as gr | |
| import json | |
| from datetime import datetime, timezone | |
| from datasets import Dataset, load_dataset | |
| from huggingface_hub import login, HfApi | |
| import pandas as pd | |
| import os | |
| import time | |
| import tempfile | |
| import logging | |
| # Setup logging | |
| logging.basicConfig(level=logging.INFO) | |
| logger = logging.getLogger(__name__) | |
| # Authenticate with Hugging Face | |
| HF_TOKEN = os.environ.get("HF_TOKEN") | |
| if HF_TOKEN: | |
| login(token=HF_TOKEN) | |
| logger.info("✅ Authenticated with Hugging Face") | |
| else: | |
| logger.warning("⚠️ HF_TOKEN not found - running without authentication") | |
| # Replace with your actual dataset name for Winter 2025 | |
| DATASET_NAME = "ysharma/gradio-hackathon-registrations-winter-2025" | |
| def get_countdown_html(): | |
| """Generate countdown HTML with current time values calculated in Python""" | |
| # Target date: November 13, 2025, 11:59 PM UTC | |
| target_date = datetime(2025, 11, 13, 23, 59, 59, tzinfo=timezone.utc) | |
| now = datetime.now(timezone.utc) | |
| difference = target_date - now | |
| if difference.total_seconds() > 0: | |
| total_seconds = int(difference.total_seconds()) | |
| days = total_seconds // (24 * 3600) | |
| hours = (total_seconds % (24 * 3600)) // 3600 | |
| minutes = (total_seconds % 3600) // 60 | |
| seconds = total_seconds % 60 | |
| else: | |
| days = hours = minutes = seconds = 0 | |
| # Calculate progress for circles (stroke-dashoffset calculation) | |
| # The circumference is 283, so we calculate the offset | |
| days_offset = 283 - min((days / 365) * 283, 283) | |
| hours_offset = 283 - ((hours / 24) * 283) | |
| minutes_offset = 283 - ((minutes / 60) * 283) | |
| seconds_offset = 283 - ((seconds / 60) * 283) | |
| return f""" | |
| <!DOCTYPE html> | |
| <html lang="en"> | |
| <head> | |
| <meta charset="UTF-8"> | |
| <meta name="viewport" content="width=device-width, initial-scale=1.0"> | |
| <title>Hackathon Countdown</title> | |
| <style> | |
| * {{ | |
| margin: 0; | |
| padding: 0; | |
| box-sizing: border-box; | |
| }} | |
| body {{ | |
| font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif; | |
| margin: 0; | |
| padding: 20px; | |
| }} | |
| .countdown-container {{ | |
| background: #C8DDD7; | |
| border-radius: 20px; | |
| padding: 40px; | |
| box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15); | |
| text-align: center; | |
| max-width: 600px; | |
| width: 100%; | |
| margin: 0 auto; | |
| display: block; | |
| }} | |
| .title {{ | |
| font-size: 28px; | |
| font-weight: 600; | |
| color: #000000; | |
| margin-bottom: 40px; | |
| }} | |
| .countdown {{ | |
| display: flex; | |
| justify-content: space-around; | |
| align-items: center; | |
| gap: 20px; | |
| flex-wrap: wrap; | |
| }} | |
| .time-unit {{ | |
| display: flex; | |
| flex-direction: column; | |
| align-items: center; | |
| min-width: 100px; | |
| }} | |
| .circle {{ | |
| position: relative; | |
| width: 100px; | |
| height: 100px; | |
| margin-bottom: 15px; | |
| }} | |
| .circle svg {{ | |
| width: 100%; | |
| height: 100%; | |
| transform: rotate(-90deg); | |
| }} | |
| .circle-bg {{ | |
| fill: none; | |
| stroke: rgba(0, 0, 0, 0.15); | |
| stroke-width: 6; | |
| }} | |
| .circle-progress {{ | |
| fill: none; | |
| stroke: #000000; | |
| stroke-width: 6; | |
| stroke-linecap: round; | |
| stroke-dasharray: 283; | |
| transition: stroke-dashoffset 0.3s ease; | |
| }} | |
| .number {{ | |
| position: absolute; | |
| top: 50%; | |
| left: 50%; | |
| transform: translate(-50%, -50%); | |
| font-size: 32px; | |
| font-weight: 700; | |
| color: #000000; | |
| font-family: 'Courier New', monospace; | |
| }} | |
| .label {{ | |
| font-size: 16px; | |
| font-weight: 500; | |
| color: #000000; | |
| text-transform: uppercase; | |
| letter-spacing: 1px; | |
| }} | |
| @keyframes pulse {{ | |
| 0% {{ opacity: 1; }} | |
| 50% {{ opacity: 0.8; }} | |
| 100% {{ opacity: 1; }} | |
| }} | |
| .number {{ | |
| animation: pulse 1s ease-in-out infinite; | |
| }} | |
| @media (max-width: 480px) {{ | |
| .countdown {{ | |
| gap: 15px; | |
| }} | |
| .circle {{ | |
| width: 80px; | |
| height: 80px; | |
| }} | |
| .number {{ | |
| font-size: 24px; | |
| }} | |
| .title {{ | |
| font-size: 22px; | |
| margin-bottom: 30px; | |
| }} | |
| }} | |
| </style> | |
| </head> | |
| <body> | |
| <div class="countdown-container"> | |
| <h1 class="title">Countdown to the Global Event Has Begun. Registrations are now open!</h1> | |
| <div class="countdown"> | |
| <div class="time-unit"> | |
| <div class="circle"> | |
| <svg> | |
| <circle class="circle-bg" cx="50" cy="50" r="45"></circle> | |
| <circle class="circle-progress" cx="50" cy="50" r="45" style="stroke-dashoffset: {days_offset:.1f};"></circle> | |
| </svg> | |
| <div class="number">{days:02d}</div> | |
| </div> | |
| <div class="label">Days</div> | |
| </div> | |
| <div class="time-unit"> | |
| <div class="circle"> | |
| <svg> | |
| <circle class="circle-bg" cx="50" cy="50" r="45"></circle> | |
| <circle class="circle-progress" cx="50" cy="50" r="45" style="stroke-dashoffset: {hours_offset:.1f};"></circle> | |
| </svg> | |
| <div class="number">{hours:02d}</div> | |
| </div> | |
| <div class="label">Hours</div> | |
| </div> | |
| <div class="time-unit"> | |
| <div class="circle"> | |
| <svg> | |
| <circle class="circle-bg" cx="50" cy="50" r="45"></circle> | |
| <circle class="circle-progress" cx="50" cy="50" r="45" style="stroke-dashoffset: {minutes_offset:.1f};"></circle> | |
| </svg> | |
| <div class="number">{minutes:02d}</div> | |
| </div> | |
| <div class="label">Minutes</div> | |
| </div> | |
| <div class="time-unit"> | |
| <div class="circle"> | |
| <svg> | |
| <circle class="circle-bg" cx="50" cy="50" r="45"></circle> | |
| <circle class="circle-progress" cx="50" cy="50" r="45" style="stroke-dashoffset: {seconds_offset:.1f};"></circle> | |
| </svg> | |
| <div class="number">{seconds:02d}</div> | |
| </div> | |
| <div class="label">Seconds</div> | |
| </div> | |
| </div> | |
| </div> | |
| <script> | |
| // Auto-refresh every second using meta refresh or JavaScript | |
| setTimeout(function(){{ | |
| location.reload(); | |
| }}, 1000); | |
| </script> | |
| </body> | |
| </html> | |
| """ | |
| def safe_add_to_dataset(registration_data, max_retries=5, retry_delay=3): | |
| """ | |
| Safely add new registration data with bulletproof error handling | |
| NEVER creates new datasets - only adds to existing ones | |
| """ | |
| try: | |
| logger.info("Starting new registration process") | |
| # Create new row with updated fields | |
| new_row = { | |
| "timestamp": registration_data["timestamp"], | |
| "full_name": registration_data["personal_info"]["full_name"], | |
| "email": registration_data["personal_info"]["email"], | |
| "hf_username": registration_data["personal_info"]["hf_username"], | |
| "gradio_usage": registration_data["personal_info"]["gradio_usage"], | |
| "track_interest": str(registration_data["participation"]["track_interest"]), | |
| "previous_participation": registration_data["participation"]["previous_participation"], | |
| "experience_level": registration_data["participation"]["experience_level"], | |
| "how_heard": registration_data["participation"]["how_heard"], | |
| "project_description": registration_data["additional"]["project_description"] or "", | |
| } | |
| logger.info("Created new row data") | |
| # Multi-attempt loading with different strategies | |
| existing_df = None | |
| load_successful = False | |
| for attempt in range(max_retries): | |
| logger.info(f"Loading attempt {attempt + 1}/{max_retries}") | |
| try: | |
| # Strategy 1: Direct parquet file access (most reliable) | |
| api = HfApi() | |
| files = api.list_repo_files(DATASET_NAME, repo_type="dataset") | |
| parquet_files = [f for f in files if f.endswith('.parquet') and 'train' in f] | |
| if parquet_files: | |
| logger.info(f"Found parquet file: {parquet_files[0]}") | |
| # Download to temporary location | |
| with tempfile.TemporaryDirectory() as temp_dir: | |
| parquet_file = api.hf_hub_download( | |
| repo_id=DATASET_NAME, | |
| filename=parquet_files[0], | |
| repo_type="dataset", | |
| cache_dir=temp_dir, | |
| force_download=True | |
| ) | |
| existing_df = pd.read_parquet(parquet_file) | |
| logger.info(f"Successfully loaded {len(existing_df)} existing rows") | |
| load_successful = True | |
| break | |
| else: | |
| logger.warning("No parquet files found") | |
| except Exception as load_error: | |
| logger.warning(f"Attempt {attempt + 1} failed: {str(load_error)[:100]}") | |
| if attempt < max_retries - 1: | |
| logger.info(f"Waiting {retry_delay} seconds before retry...") | |
| time.sleep(retry_delay) | |
| continue | |
| # CRITICAL SAFETY CHECK: Never proceed without existing data | |
| if not load_successful or existing_df is None: | |
| error_msg = "🚨 CRITICAL SAFETY ERROR: Could not load existing dataset after multiple attempts." | |
| logger.error(error_msg) | |
| logger.error("🚨 REFUSING to proceed to prevent data loss!") | |
| logger.error("🚨 Please check dataset manually or contact administrators.") | |
| return False, ( | |
| "❌ Registration temporarily unavailable due to technical issues. " | |
| "Please try again in a few minutes. If the problem persists, contact support." | |
| ) | |
| # Check for duplicates | |
| duplicate_check = existing_df[ | |
| (existing_df['email'].str.lower() == new_row['email'].lower()) | | |
| (existing_df['hf_username'].str.lower() == new_row['hf_username'].lower()) | |
| ] | |
| if len(duplicate_check) > 0: | |
| logger.warning("Duplicate registration attempt detected") | |
| return False, "❌ Error: This email or Hugging Face username is already registered." | |
| # Add new row safely | |
| combined_df = pd.concat([existing_df, pd.DataFrame([new_row])], ignore_index=True) | |
| logger.info(f"Combined data now has {len(combined_df)} rows (was {len(existing_df)})") | |
| # Create timestamped backup before upload | |
| backup_timestamp = int(time.time()) | |
| try: | |
| # Convert to Dataset and upload | |
| logger.info("Converting to HuggingFace Dataset format...") | |
| updated_dataset = Dataset.from_pandas(combined_df) | |
| # Create backup first | |
| backup_name = f"{DATASET_NAME}-auto-backup-{backup_timestamp}" | |
| logger.info(f"Creating backup: {backup_name}") | |
| updated_dataset.push_to_hub(backup_name, private=True) | |
| logger.info("Pushing to main dataset...") | |
| updated_dataset.push_to_hub(DATASET_NAME, private=True) | |
| logger.info("✅ Successfully saved new registration") | |
| logger.info(f"Total rows in dataset: {len(combined_df)}") | |
| # Quick verification | |
| time.sleep(2) | |
| try: | |
| verify_files = api.list_repo_files(DATASET_NAME, repo_type="dataset") | |
| logger.info("✅ Upload verification: Files updated successfully") | |
| except: | |
| logger.warning("⚠️ Could not verify upload (this may be normal)") | |
| return True, "Registration successful!" | |
| except Exception as upload_error: | |
| error_msg = str(upload_error).lower() | |
| if any(indicator in error_msg for indicator in ['rate limit', '429', 'too many requests']): | |
| logger.warning("🚨 Rate limit hit - registration system temporarily busy") | |
| return False, "⏳ Registration temporarily unavailable due to high server load. Please try again in 10-15 minutes." | |
| else: | |
| logger.error(f"Upload failed: {upload_error}") | |
| return False, f"❌ Registration failed during upload: {str(upload_error)}" | |
| except Exception as e: | |
| logger.error(f"❌ Unexpected error in registration: {e}") | |
| import traceback | |
| traceback.print_exc() | |
| return False, f"❌ Registration failed: {str(e)}" | |
| def verify_registration(email, hf_username): | |
| """ | |
| Verify if a user is registered by checking both email and HF username | |
| Returns registration details if both match | |
| """ | |
| try: | |
| # Validate inputs | |
| if not email or not email.strip(): | |
| return "❌ Please enter your email address" | |
| if not hf_username or not hf_username.strip(): | |
| return "❌ Please enter your Hugging Face username" | |
| logger.info(f"Verification attempt for email: {email}") | |
| # Load dataset | |
| try: | |
| dataset = load_dataset(DATASET_NAME, split="train") | |
| df = dataset.to_pandas() | |
| logger.info(f"Loaded dataset with {len(df)} registrations") | |
| except Exception as load_error: | |
| logger.error(f"Failed to load dataset: {load_error}") | |
| return "❌ Unable to verify registration at this time. Please try again later." | |
| # Search for exact match (both email AND username must match) | |
| email_lower = email.strip().lower() | |
| username_lower = hf_username.strip().lower() | |
| match = df[ | |
| (df['email'].str.lower() == email_lower) & | |
| (df['hf_username'].str.lower() == username_lower) | |
| ] | |
| if len(match) == 0: | |
| # Check if email exists with different username | |
| email_exists = df[df['email'].str.lower() == email_lower] | |
| username_exists = df[df['hf_username'].str.lower() == username_lower] | |
| if len(email_exists) > 0 and len(username_exists) == 0: | |
| return "❌ Email found but Hugging Face username doesn't match. Please check your username." | |
| elif len(username_exists) > 0 and len(email_exists) == 0: | |
| return "❌ Hugging Face username found but email doesn't match. Please check your email." | |
| else: | |
| return "❌ No registration found with this email and Hugging Face username combination." | |
| # Registration found - format the details | |
| registration = match.iloc[0] | |
| # Parse timestamp | |
| try: | |
| timestamp = pd.to_datetime(registration['timestamp']) | |
| reg_date = timestamp.strftime("%B %d, %Y at %I:%M %p UTC") | |
| except: | |
| reg_date = registration['timestamp'] | |
| # Format track interests | |
| track_interest = registration['track_interest'] | |
| if isinstance(track_interest, str): | |
| # Clean up the string representation of list | |
| track_interest = track_interest.strip("[]'\"").replace("'", "") | |
| result = f""" | |
| ## ✅ Registration Confirmed! | |
| **Participant Details:** | |
| - **Full Name:** {registration['full_name']} | |
| - **Email:** {registration['email']} | |
| - **Hugging Face Username:** {registration['hf_username']} | |
| - **Registered On:** {reg_date} | |
| **Hackathon Participation:** | |
| - **Track Interest:** {track_interest} | |
| - **Gradio Usage:** {registration['gradio_usage']} | |
| - **Previous Participation:** {registration['previous_participation']} | |
| - **Experience Level:** {registration['experience_level']} | |
| - **How You Heard:** {registration['how_heard']} | |
| **Project Idea:** | |
| {registration['project_description'] if registration['project_description'] else '_No project description provided_'} | |
| --- | |
| **Next Steps:** | |
| - 🔑 API and Compute credits will be distributed before or during the hackathon | |
| - 💬 Join our Discord community channel `mcp-1st-birthday-official🏆`: https://discord.gg/92sEPT2Zhv | |
| - 📧 Watch your email for important updates | |
| - 🚀 Start planning your project! | |
| """ | |
| logger.info(f"✅ Verification successful for {email}") | |
| return result | |
| except Exception as e: | |
| logger.error(f"Error during verification: {e}") | |
| import traceback | |
| traceback.print_exc() | |
| return f"❌ An error occurred during verification: {str(e)}" | |
| def submit_registration(full_name, email, hf_username, gradio_usage, | |
| track_interest, previous_participation, experience_level, how_heard, | |
| acknowledgment, project_description): | |
| """Process the registration form submission with enhanced validation""" | |
| # Enhanced validation | |
| if not full_name or not full_name.strip(): | |
| return "❌ Error: Please enter your full name" | |
| if not email or not email.strip(): | |
| return "❌ Error: Please enter your email address" | |
| if not hf_username or not hf_username.strip(): | |
| return "❌ Error: Please enter your Hugging Face username" | |
| if not gradio_usage: | |
| return "❌ Error: Please select how you're currently using Gradio" | |
| if not track_interest: | |
| return "❌ Error: Please select at least one track of interest" | |
| if not previous_participation: | |
| return "❌ Error: Please select your hackathon experience" | |
| if not experience_level: | |
| return "❌ Error: Please select your experience level" | |
| if not how_heard: | |
| return "❌ Error: Please select how you heard about this hackathon" | |
| if not acknowledgment: | |
| return "❌ Error: Please confirm your acknowledgment to participate" | |
| # Email format validation | |
| import re | |
| email_pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$' | |
| if not re.match(email_pattern, email.strip()): | |
| return "❌ Error: Please enter a valid email address" | |
| # Process the registration data | |
| registration_data = { | |
| "timestamp": datetime.now().isoformat(), | |
| "personal_info": { | |
| "full_name": full_name.strip(), | |
| "email": email.strip().lower(), | |
| "hf_username": hf_username.strip(), | |
| "gradio_usage": gradio_usage, | |
| }, | |
| "participation": { | |
| "track_interest": track_interest, | |
| "previous_participation": previous_participation, | |
| "experience_level": experience_level, | |
| "how_heard": how_heard, | |
| }, | |
| "additional": { | |
| "project_description": project_description.strip() if project_description else None, | |
| } | |
| } | |
| # Save to Hugging Face dataset with bulletproof error handling | |
| success, message = safe_add_to_dataset(registration_data) | |
| if not success: | |
| return f"❌ Registration failed: {message}" | |
| return f"""✅ Registration Successful! | |
| Thank you, {full_name}! Your registration has been received and saved.<br> | |
| 📧 You will receive information about API credits as we finalize sponsor partnerships.<br> | |
| 🔑 API and Compute credits will be distributed before or during the Hackathon starting date.<br> | |
| 💬 Be sure to **join the Huggingface organization** for regular updates on the hackathon and **to submit your entries**. Join our Discord community channel `mcp-1st-birthday-official🏆` for updates and support during the event: https://discord.gg/92sEPT2Zhv | |
| **See you at the hackathon! 🚀**""" | |
| # Health check function | |
| def check_dataset_health(): | |
| """Check if the dataset is accessible and healthy""" | |
| try: | |
| api = HfApi() | |
| files = api.list_repo_files(DATASET_NAME, repo_type="dataset") | |
| parquet_files = [f for f in files if f.endswith('.parquet')] | |
| if parquet_files: | |
| logger.info(f"✅ Dataset health check passed - found {len(parquet_files)} parquet files") | |
| return True | |
| else: | |
| logger.warning("⚠️ Dataset health check: No parquet files found") | |
| return False | |
| except Exception as e: | |
| logger.error(f"❌ Dataset health check failed: {e}") | |
| return False | |
| # Initialize with health check | |
| logger.info("🚀 Starting Gradio Hackathon Registration System - Winter 2025") | |
| logger.info(f"📊 Dataset: {DATASET_NAME}") | |
| if check_dataset_health(): | |
| logger.info("✅ System ready - dataset is healthy") | |
| else: | |
| logger.warning("⚠️ System starting with dataset health warnings") | |
| # Custom CSS for MCP theme | |
| custom_css = """ | |
| .gradio-container { | |
| font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif; | |
| } | |
| .header-gradient { | |
| color: #000000; | |
| } | |
| /* MCP-themed Submit Button Styling */ | |
| #gradient-submit-btn { | |
| background: #C8DDD7 !important; | |
| border: 2px solid #000000 !important; | |
| color: #000000 !important; | |
| font-weight: 600 !important; | |
| font-size: 18px !important; | |
| padding: 16px 32px !important; | |
| border-radius: 12px !important; | |
| box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15) !important; | |
| transition: all 0.3s ease !important; | |
| text-transform: none !important; | |
| } | |
| #gradient-submit-btn:hover { | |
| transform: translateY(-2px) !important; | |
| box-shadow: 0 6px 20px rgba(0, 0, 0, 0.25) !important; | |
| background: #B8CEC7 !important; | |
| } | |
| #gradient-submit-btn:active { | |
| transform: translateY(0px) !important; | |
| box-shadow: 0 2px 8px rgba(0, 0, 0, 0.2) !important; | |
| } | |
| /* Disabled state for the button */ | |
| #gradient-submit-btn:disabled { | |
| opacity: 0.6 !important; | |
| cursor: not-allowed !important; | |
| transform: none !important; | |
| } | |
| /* Verify button styling - Inverted MCP theme */ | |
| #verify-btn { | |
| background: #000000 !important; | |
| border: 2px solid #C8DDD7 !important; | |
| color: #C8DDD7 !important; | |
| font-weight: 600 !important; | |
| font-size: 16px !important; | |
| padding: 12px 24px !important; | |
| border-radius: 8px !important; | |
| box-shadow: 0 3px 10px rgba(200, 221, 215, 0.3) !important; | |
| transition: all 0.3s ease !important; | |
| } | |
| #verify-btn:hover { | |
| transform: translateY(-2px) !important; | |
| box-shadow: 0 5px 15px rgba(200, 221, 215, 0.5) !important; | |
| background: #1a1a1a !important; | |
| border-color: #D8EDE7 !important; | |
| } | |
| """ | |
| # Function to update countdown periodically | |
| def update_countdown(): | |
| """Update the countdown HTML""" | |
| return gr.HTML(get_countdown_html()) | |
| # Create the Gradio interface | |
| with gr.Blocks(title="Gradio Agents & MCP Hackathon - Winter 2025", css=custom_css, theme="ocean") as demo: | |
| # Header | |
| gr.Markdown(""" | |
| # MCP's 1st Birthday - Hosted by Anthropic and Gradio | |
| **Join our [Discord Community](https://discord.gg/92sEPT2Zhv) channel `mcp-1st-birthday-official🏆` for active support during the hackathon.** | |
| **NOTE: If the registration app says you are registered, then that information is correct and you don't need to send us anything else. NO CONFIRMATION EMAILS ARE SENT FROM OUR SIDE.** | |
| **📅 Event Dates:** November 14-30, 2025 (17 days, 3 weekends) | **🏆 Prizes: $17,000+ USD in cash prizes** | **💻 Location:** Online & Global | |
| **🎁 FREE API & Compute Credits** (Details announced soon): | |
| - API credits from major AI providers | |
| - Access to latest and strongest LLMs | |
| - Compute resources for building your projects | |
| **The definitive Agents & MCP event is back!** OpenAI, Microsoft, Google DeepMind, and numerous startups have already adopted MCP. Join the community that launched the MCP developer movement. Participate and stand a chance to learn the latest AI technologies and also Win BIG! | |
| """) | |
| # Create countdown HTML component that will be updated | |
| countdown_display = gr.HTML(get_countdown_html()) | |
| gr.Markdown("---") | |
| # Create tabs | |
| with gr.Tabs(): | |
| # Registration Tab | |
| with gr.Tab("📝 Register"): | |
| with gr.Row(): | |
| with gr.Column(): | |
| # Personal Information Section | |
| gr.Markdown("## 1. Personal Information") | |
| full_name = gr.Textbox( | |
| label="Full Name *", | |
| placeholder="Your full name as you'd like it on certificates", | |
| max_lines=1 | |
| ) | |
| email = gr.Textbox( | |
| label="Email Address *", | |
| placeholder="Primary contact email (we'll send important updates here)", | |
| max_lines=1 | |
| ) | |
| hf_username = gr.Textbox( | |
| label="Hugging Face Username *", | |
| placeholder="Required for organization access and submissions", | |
| max_lines=1 | |
| ) | |
| gradio_usage = gr.Radio( | |
| label="How are you currently using Gradio? *", | |
| choices=[ | |
| "Professional work - My company uses Gradio", | |
| "Personal projects - Building side projects", | |
| "Academic/Research - University or research work", | |
| "Learning - New to Gradio, want to learn", | |
| "Not using yet - Interested to start" | |
| ], | |
| info="Helps us understand our community better" | |
| ) | |
| with gr.Column(): | |
| # Hackathon Participation Section | |
| gr.Markdown("## 2. Hackathon Participation") | |
| track_interest = gr.CheckboxGroup( | |
| label="Which track interests you most? *", | |
| choices=[ | |
| "Track 1: Building MCP", | |
| "Track 2: MCP in Action (Agents)", | |
| ] | |
| ) | |
| previous_participation = gr.Radio( | |
| label="Hackathon experience *", | |
| choices=[ | |
| "I participated in June 2025 Agents & MCP Hackathon", | |
| "I've done other AI hackathons before", | |
| "This is my first AI hackathon" | |
| ] | |
| ) | |
| experience_level = gr.Radio( | |
| label="Your experience with AI/Agents development *", | |
| choices=[ | |
| "Beginner - New to AI development", | |
| "Intermediate - Some AI projects", | |
| "Advanced - Regular AI developer", | |
| "Expert - Professional AI engineer" | |
| ] | |
| ) | |
| how_heard = gr.Dropdown( | |
| label="How did you hear about this hackathon? *", | |
| choices=[ | |
| "Hugging Face email/newsletter", | |
| "Twitter/X", | |
| "LinkedIn", | |
| "Discord", | |
| "From a colleague/friend", | |
| "YouTube", | |
| "Reddit", | |
| "Sponsor announcement", | |
| "I participated in June 2025", | |
| "Other" | |
| ] | |
| ) | |
| with gr.Row(): | |
| with gr.Column(): | |
| # Additional Information Section | |
| gr.Markdown("## 3. Additional Information") | |
| project_description = gr.Textbox( | |
| label="What type of project are you most excited to build?", | |
| placeholder="Brief description of your project idea or what interests you most", | |
| lines=3 | |
| ) | |
| with gr.Column(): | |
| # Acknowledgment Section | |
| gr.Markdown("## 4. Acknowledgment") | |
| acknowledgment = gr.Checkbox( | |
| label="Acknowledgment *", | |
| info="""I commit to actively participate and submit a project by November 30, 2025. I understand that API/compute credits are provided to support hackathon participation and should be used for building my hackathon project. I commit to using these credits responsibly during the event period.""", | |
| ) | |
| # Submit button | |
| submit_btn = gr.Button("🚀 Register for Hackathon", variant="primary", size="lg", elem_id="gradient-submit-btn") | |
| # Output | |
| output = gr.Markdown() | |
| # Enhanced submit function | |
| def handle_registration_with_state(*args): | |
| try: | |
| result = submit_registration(*args) | |
| return result, gr.Button("🚀 Register for Hackathon", interactive=True, variant="primary") | |
| except Exception as e: | |
| logger.error(f"Registration handling error: {e}") | |
| return f"❌ An unexpected error occurred: {str(e)}", gr.Button("🚀 Register for Hackathon", interactive=True, variant="primary") | |
| # Click event with updated inputs | |
| submit_btn.click( | |
| fn=lambda *args: (gr.Button("⏳ Processing Registration...", interactive=False, variant="secondary"), ""), | |
| inputs=[ | |
| full_name, email, hf_username, gradio_usage, | |
| track_interest, previous_participation, experience_level, how_heard, | |
| acknowledgment, project_description, | |
| ], | |
| outputs=[submit_btn, output], | |
| queue=False | |
| ).then( | |
| fn=handle_registration_with_state, | |
| inputs=[ | |
| full_name, email, hf_username, gradio_usage, | |
| track_interest, previous_participation, experience_level, how_heard, | |
| acknowledgment, project_description, | |
| ], | |
| outputs=[output, submit_btn], | |
| queue=True | |
| ) | |
| # Verification Tab | |
| with gr.Tab("🔍 Verify Registration"): | |
| gr.Markdown(""" | |
| ## Check Your Registration Status | |
| Enter your email address and Hugging Face username to verify your registration and view your details. | |
| **Note:** Both email and username must match exactly for security purposes. | |
| """) | |
| with gr.Row(): | |
| with gr.Column(): | |
| verify_email = gr.Textbox( | |
| label="Email Address", | |
| placeholder="Enter your registered email", | |
| max_lines=1 | |
| ) | |
| verify_hf_username = gr.Textbox( | |
| label="Hugging Face Username", | |
| placeholder="Enter your registered HF username", | |
| max_lines=1 | |
| ) | |
| verify_btn = gr.Button("🔍 Check Registration Status", variant="primary", size="lg", elem_id="verify-btn") | |
| with gr.Column(): | |
| gr.Markdown(""" | |
| ### Need Help? | |
| - Make sure you enter the **exact** email and username you used during registration | |
| - Both fields are **case-insensitive** but must match your registration | |
| - If you can't find your registration, try registering again or contact support | |
| **Support:** | |
| - Discord: https://discord.gg/92sEPT2Zhv | |
| - Email: [email protected] | |
| """) | |
| verify_output = gr.Markdown() | |
| # Verification click event | |
| verify_btn.click( | |
| fn=verify_registration, | |
| inputs=[verify_email, verify_hf_username], | |
| outputs=verify_output | |
| ) | |
| # Footer | |
| gr.Markdown(""" | |
| **Questions?** Join Huggingface [Discord](https://discord.gg/92sEPT2Zhv) or email: [email protected] | |
| """) | |
| # Set up a timer to update the countdown every second | |
| # This will refresh the countdown display periodically | |
| demo.load(update_countdown, None, countdown_display, every=1) | |
| if __name__ == "__main__": | |
| demo.launch(allowed_paths=["."]) |