initial version

README.md

@@ -11,4 +11,98 @@ license: apache-2.0
 short_description: Instantly match hackathon participants into ideal teams!
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🤖 AI-Powered HackBuddyAI
+
+This project is a web application that helps hackathon organizers automatically form balanced teams from a list of participants. It uses a `TinyCodeAgent` to analyze participant skills and goals, creating optimal teams based on criteria defined by the organizer.
+
+The application features a two-tab interface:
+1.  **Participant Registration**: A form for participants to submit their profile, including skills, background, and what they want to achieve during the hackathon.
+2.  **Organizer Dashboard**: A view for the organizer to see all registered participants, define matching criteria, and run the AI-powered team formation process.
+
+## Tech Stack
+-   **Backend**: Python
+-   **AI Agent Framework**: `TinyCodeAgent`
+-   **Web UI**: Gradio
+-   **Data Handling**: Pandas
+-   **Database**: SQLite
+
+---
+
+## Setup and Installation
+
+### 1. Prerequisites
+-   Python 3.8+
+-   An OpenAI API key
+
+### 2. Installation
+1.  **Clone the repository** (if applicable) or ensure you have the project files in a directory.
+
+2.  **Navigate to the project directory**:
+    ```bash
+    cd path/to/project
+    ```
+
+3.  **Create a virtual environment** (recommended):
+    ```bash
+    python -m venv venv
+    source venv/bin/activate  # On Windows, use `venv\Scripts\activate`
+    ```
+
+4.  **Install dependencies**:
+    The project relies on the `tinyagent` library. Assuming it is available in your environment, install the other required packages:
+    ```bash
+    pip install -r hackathon_organizer/requirements.txt
+    ```
+
+### 3. Configure Environment Variables
+You must set your OpenAI API key as an environment variable. The application will not run without it.
+
+-   **On macOS/Linux**:
+    ```bash
+    export OPENAI_API_KEY="your_api_key_here"
+    ```
+-   **On Windows (Command Prompt)**:
+    ```bash
+    set OPENAI_API_KEY="your_api_key_here"
+    ```
+
+---
+
+## 🚀 Running the Application
+
+Once the setup is complete, you can launch the Gradio web application using one of the following methods:
+
+### Method 1: Using the main script (recommended)
+
+```bash
+python main.py
+```
+
+This script handles all the necessary path configurations and launches the application.
+
+### Method 2: Running app.py directly
+
+```bash
+cd hackathon_organizer
+python app.py
+```
+
+Either method will start a local web server, and you can access the application at the URL provided in the console (usually `http://127.0.0.1:7860`).
+
+The application will create a `hackathon_participants.db` file in the working directory to store the participant data.
+
+---
+
+## 🧪 Running Tests
+
+The project includes unit tests for the database and the agent setup logic. The tests are located in the `tests/` directory.
+
+To run the tests:
+
+```bash
+# From the project root directory
+cd hackathon_organizer
+python -m unittest discover tests
+```
+
+The tests are designed to run without needing an active internet connection or a valid API key. They use mocks to simulate agent behavior and an in-memory database for testing database operations. 

app_simple.py

@@ -0,0 +1,146 @@
+import gradio as gr
+import pandas as pd
+import logging
+import sys
+import os
+
+from database import initialize_database, add_participant, get_participants_dataframe
+
+# --- Logging Setup ---
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[logging.StreamHandler(sys.stdout)]
+)
+logger = logging.getLogger('app_simple')
+
+# --- Initial Setup ---
+logger.info("Initializing database...")
+initialize_database()
+
+# --- Gradio UI Functions ---
+
+def register_participant(name, email, linkedin, background, goals):
+    """Callback function to register a new participant."""
+    if not all([name, email]):
+        return "Please provide at least a name and email.", get_participants_dataframe()
+    
+    participant_data = {
+        "name": name,
+        "email": email,
+        "linkedin_profile": linkedin,
+        "background": background,
+        "goals": goals
+    }
+    try:
+        add_participant(participant_data)
+        feedback = f"✅ Success! Participant '{name}' registered."
+        logger.info(f"Registered new participant: {email}")
+    except Exception as e:
+        feedback = f"❌ Error! Could not register participant. Reason: {e}"
+        logger.error(f"Failed to register participant {email}: {e}")
+        
+    return feedback, get_participants_dataframe()
+
+def refresh_participants_list():
+    """Callback to reload the participant data from the database."""
+    return get_participants_dataframe()
+
+def mock_matching_process(organizer_criteria):
+    """Mock function for the matching process (without using TinyCodeAgent)."""
+    participants_df = get_participants_dataframe()
+    if len(participants_df) < 2:
+        logger.warning("Matching process aborted: not enough participants.")
+        return "Cannot run matching with fewer than 2 participants."
+
+    # Create a simple mock output
+    result = f"""
+## Team Matching Results
+
+**Criteria used**: {organizer_criteria}
+
+### Team 1
+* **{participants_df['name'].iloc[0] if len(participants_df) > 0 else 'No participants'}**
+* **{participants_df['name'].iloc[1] if len(participants_df) > 1 else 'No participants'}**
+
+**Justification**: This is a mock team created for demonstration purposes.
+
+### Team 2
+* **{participants_df['name'].iloc[2] if len(participants_df) > 2 else 'No participants'}**
+* **{participants_df['name'].iloc[3] if len(participants_df) > 3 else 'No participants'}**
+
+**Justification**: This is another mock team created for demonstration purposes.
+
+*Note: This is a simplified version without the AI matching. The full version would use TinyCodeAgent to create optimized teams.*
+"""
+    return result
+
+# --- Gradio App Definition ---
+
+with gr.Blocks(theme=gr.themes.Soft(), title="HackBuddyAI (Simple)") as app:
+    gr.Markdown("# 🤖 HackBuddyAI (Simple Version)")
+    gr.Markdown("*This is a simplified version without the AI matching component.*")
+    
+    with gr.Tabs():
+        with gr.TabItem("👤 Participant Registration"):
+            gr.Markdown("## Welcome, Participant!")
+            gr.Markdown("Fill out the form below to register for the hackathon.")
+            with gr.Row():
+                with gr.Column():
+                    name_in = gr.Textbox(label="Full Name")
+                    email_in = gr.Textbox(label="Email Address")
+                    linkedin_in = gr.Textbox(label="LinkedIn Profile URL", placeholder="Optional")
+                with gr.Column():
+                    background_in = gr.Textbox(label="Your Background & Skills", lines=5, placeholder="e.g., Python developer with 3 years of experience, specializing in Django and REST APIs...")
+                    goals_in = gr.Textbox(label="Your Goals for this Hackathon", lines=5, placeholder="e.g., I want to learn about machine learning and work on a cool data visualization project...")
+            
+            submit_button = gr.Button("Register", variant="primary")
+            registration_feedback = gr.Markdown()
+
+        with gr.TabItem("👑 Organizer Dashboard"):
+            gr.Markdown("## Welcome, Organizer!")
+            gr.Markdown("Here you can view registered participants and run the team matching process.")
+            
+            with gr.Accordion("View Registered Participants", open=False):
+                refresh_button = gr.Button("🔄 Refresh List")
+                participants_df_out = gr.DataFrame(value=get_participants_dataframe, interactive=False)
+
+            gr.Markdown("### Run Matching")
+            organizer_criteria_in = gr.Textbox(
+                label="Matching Criteria", 
+                lines=4,
+                value="Create teams of 3. Try to balance skills in each team (e.g., frontend, backend, data).",
+                placeholder="Describe your ideal team composition..."
+            )
+            run_button = gr.Button("🚀 Run Matching", variant="primary")
+            
+            gr.Markdown("### 🤝 Matched Teams")
+            matching_results_out = gr.Markdown("Matching has not been run yet.")
+
+    # --- Event Handlers ---
+    submit_button.click(
+        fn=register_participant,
+        inputs=[name_in, email_in, linkedin_in, background_in, goals_in],
+        outputs=[registration_feedback, participants_df_out]
+    )
+    
+    refresh_button.click(
+        fn=refresh_participants_list,
+        inputs=[],
+        outputs=[participants_df_out]
+    )
+
+    run_button.click(
+        fn=mock_matching_process,
+        inputs=[organizer_criteria_in],
+        outputs=[matching_results_out]
+    )
+
+# --- Launching the App ---
+if __name__ == "__main__":
+    try:
+        logger.info("Launching Gradio app (simple version)...")
+        # queue() is important for handling multiple users
+        app.queue().launch(share=False)
+    except KeyboardInterrupt:
+        logger.info("Gradio app shutting down.") 

generate_participants.py

@@ -1,372 +0,0 @@
-#!/usr/bin/env python3
-"""
-Generate Synthetic Hackathon Participants
-
-This script creates 100 diverse hackathon participants and saves them to the database.
-The participants represent various personas that might attend a hackathon focused on
-"Connected Experiences" and AI agents.
-"""
-import random
-import sys
-import os
-from faker import Faker
-from hackathon_organizer.database import initialize_database, add_participant, get_participants_dataframe
-
-# Initialize Faker for generating realistic names and emails
-fake = Faker()
-
-# Define various participant personas and attributes
-TECHNICAL_BACKGROUNDS = [
-    # Developers
-    "Full-stack developer with {years} years of experience in {stack}. {additional}",
-    "Backend engineer specializing in {backend_tech}. {additional}",
-    "Frontend developer focused on {frontend_tech}. {additional}",
-    "Mobile developer with expertise in {mobile_tech}. {additional}",
-    "DevOps engineer with experience in {devops_tech}. {additional}",
-    "Data scientist working with {ds_tech}. {additional}",
-    "Machine learning engineer focused on {ml_tech}. {additional}",
-    "AI researcher specializing in {ai_tech}. {additional}",
-    "Game developer using {game_tech}. {additional}",
-    "Embedded systems engineer working with {embedded_tech}. {additional}",
-    
-    # Technical but not coding-focused
-    "UX/UI designer with {years} years of experience. {additional}",
-    "Product manager for {product_type} products. {additional}",
-    "QA engineer with expertise in {qa_tech}. {additional}",
-    "Technical writer specializing in {writing_focus}. {additional}",
-    "Solution architect with background in {arch_focus}. {additional}",
-]
-
-NON_TECHNICAL_BACKGROUNDS = [
-    "Marketing professional with experience in {marketing_focus}. {additional}",
-    "Business development specialist in the {industry} industry. {additional}",
-    "Project manager with {years} years of experience in {pm_focus}. {additional}",
-    "Entrepreneur and founder of a {startup_type} startup. {additional}",
-    "Student studying {field} at {university}. {additional}",
-    "Design thinking facilitator and innovation consultant. {additional}",
-    "Content creator focusing on {content_focus}. {additional}",
-    "Sales professional in the {sales_industry} sector. {additional}",
-    "HR specialist interested in tech talent and culture. {additional}",
-    "Non-profit professional looking to leverage technology for social impact. {additional}",
-]
-
-GOALS = [
-    # Learning-focused
-    "I want to learn about AI and how it can enhance user experiences at events.",
-    "I'm here to understand how to build AI agents and apply them to real-world problems.",
-    "I hope to gain practical experience with AI technologies and expand my technical skills.",
-    "I want to learn from experienced developers and improve my coding abilities.",
-    "I'm looking to understand how AI can create more meaningful human connections.",
-    
-    # Project-focused
-    "I want to build a prototype that demonstrates the power of AI in connecting people.",
-    "I'm hoping to create an innovative solution that addresses the challenges of virtual events.",
-    "My goal is to develop an AI agent that enhances real-world social interactions.",
-    "I want to build something impressive for my portfolio that showcases my skills.",
-    "I'm aiming to create a practical tool that event organizers can actually use.",
-    
-    # Networking-focused
-    "I'm primarily here to network with other professionals in the AI and event space.",
-    "I want to meet potential co-founders for a startup idea I've been developing.",
-    "I'm looking to connect with mentors who can guide my career in tech.",
-    "I hope to find collaborators for future projects beyond this hackathon.",
-    "I want to expand my professional network in the Toronto tech community.",
-    
-    # Career-focused
-    "I'm exploring career opportunities in AI development and looking to showcase my skills.",
-    "I want to transition from my current role to a more tech-focused position.",
-    "I'm hoping this experience will help me land a job at an innovative tech company.",
-    "I want to demonstrate my abilities to potential employers or clients.",
-    "I'm building skills that will help me advance in my current organization.",
-    
-    # Fun/Experience-focused
-    "I'm here for the creative experience and the thrill of building something in 24 hours.",
-    "I want to have fun while challenging myself technically.",
-    "I'm curious about hackathons and wanted to experience one firsthand.",
-    "I enjoy the collaborative atmosphere of hackathons and the energy they generate.",
-    "I'm looking for a break from my routine and a chance to work on something different.",
-]
-
-# Technical stack components
-STACK_COMPONENTS = {
-    "years": [str(i) for i in range(1, 16)],
-    "stack": [
-        "JavaScript/TypeScript and Python", "MERN stack", "MEAN stack", "Ruby on Rails", 
-        "Django and React", "Vue.js and Node.js", "PHP and Laravel", "Java Spring Boot",
-        ".NET and Angular", "Go and React", "Python Flask and Vue.js"
-    ],
-    "backend_tech": [
-        "Node.js and Express", "Django and PostgreSQL", "Ruby on Rails", "Java Spring Boot",
-        "ASP.NET Core", "PHP and Laravel", "Go microservices", "Python FastAPI",
-        "GraphQL APIs", "Serverless architectures on AWS"
-    ],
-    "frontend_tech": [
-        "React and Redux", "Angular and RxJS", "Vue.js and Vuex", "Svelte and SvelteKit",
-        "Next.js", "Gatsby", "React Native", "Flutter", "TypeScript and Material UI",
-        "Tailwind CSS and Alpine.js"
-    ],
-    "mobile_tech": [
-        "React Native", "Flutter", "Swift for iOS", "Kotlin for Android",
-        "Xamarin", "Ionic", "PWAs", "Unity for mobile games", "NativeScript",
-        "Mobile AR/VR applications"
-    ],
-    "devops_tech": [
-        "Kubernetes and Docker", "AWS infrastructure", "Azure DevOps", "Google Cloud Platform",
-        "CI/CD pipelines", "Terraform and infrastructure as code", "Jenkins and GitLab CI",
-        "Monitoring and observability tools", "Site Reliability Engineering practices",
-        "Security automation"
-    ],
-    "ds_tech": [
-        "Python, Pandas, and scikit-learn", "R and Tidyverse", "SQL and data warehousing",
-        "Tableau and data visualization", "Big data technologies like Spark",
-        "ETL pipelines", "Statistical analysis", "A/B testing methodologies",
-        "Natural Language Processing", "Computer Vision"
-    ],
-    "ml_tech": [
-        "TensorFlow and Keras", "PyTorch", "scikit-learn", "deep learning models",
-        "MLOps and model deployment", "reinforcement learning", "computer vision algorithms",
-        "NLP models", "recommendation systems", "time series forecasting"
-    ],
-    "ai_tech": [
-        "large language models", "generative AI", "conversational agents", "computer vision systems",
-        "reinforcement learning", "multimodal AI", "AI ethics and responsible AI",
-        "autonomous systems", "AI for social good", "explainable AI"
-    ],
-    "game_tech": [
-        "Unity", "Unreal Engine", "Godot", "WebGL", "AR/VR development",
-        "mobile game development", "game AI", "procedural generation",
-        "multiplayer networking", "game physics"
-    ],
-    "embedded_tech": [
-        "Arduino", "Raspberry Pi", "IoT devices", "embedded Linux",
-        "RTOS", "C/C++ for microcontrollers", "sensor networks",
-        "firmware development", "hardware interfaces", "low-power systems"
-    ],
-    "product_type": [
-        "SaaS", "mobile", "enterprise", "consumer", "AI-powered",
-        "IoT", "fintech", "healthtech", "edtech", "e-commerce"
-    ],
-    "qa_tech": [
-        "automated testing", "Selenium and Cypress", "performance testing",
-        "security testing", "mobile app testing", "API testing",
-        "test-driven development", "behavior-driven development",
-        "continuous integration testing", "accessibility testing"
-    ],
-    "writing_focus": [
-        "API documentation", "user guides", "developer tutorials",
-        "knowledge bases", "technical blogs", "software requirements",
-        "open source documentation", "technical specifications",
-        "UX writing", "compliance documentation"
-    ],
-    "arch_focus": [
-        "cloud architectures", "microservices", "serverless",
-        "enterprise systems", "distributed systems", "API design",
-        "security architectures", "data platforms", "IoT systems",
-        "mobile and web applications"
-    ],
-    "additional": [
-        "I enjoy working in collaborative environments.",
-        "I'm passionate about creating accessible technology.",
-        "I've contributed to several open source projects.",
-        "I'm interested in ethical technology and responsible innovation.",
-        "I enjoy mentoring junior developers.",
-        "I have a background in design thinking.",
-        "I've worked in startups and enterprise environments.",
-        "I'm particularly interested in AI ethics.",
-        "I love solving complex algorithmic problems.",
-        "I focus on creating user-centered solutions.",
-        "I have experience leading small technical teams.",
-        "I'm self-taught and constantly learning new technologies.",
-        "I have a computer science degree but learned most of my skills on the job.",
-        "I'm currently transitioning careers into tech.",
-        "I'm an advocate for diversity in tech.",
-        "I've organized tech meetups and community events.",
-        "I'm interested in the intersection of technology and sustainability.",
-        "I have experience in both technical and business roles.",
-        "I'm passionate about making technology more accessible to everyone.",
-        "I enjoy the challenges of working with legacy systems.",
-        "",  # Empty for some participants
-    ]
-}
-
-# Non-technical components
-NON_TECH_COMPONENTS = {
-    "marketing_focus": [
-        "digital marketing", "content strategy", "brand development",
-        "social media campaigns", "event promotion", "growth hacking",
-        "community building", "influencer partnerships", "SEO/SEM",
-        "product marketing"
-    ],
-    "industry": [
-        "technology", "healthcare", "finance", "education", "retail",
-        "entertainment", "manufacturing", "non-profit", "government",
-        "hospitality"
-    ],
-    "years": [str(i) for i in range(1, 16)],
-    "pm_focus": [
-        "agile methodologies", "waterfall approaches", "hybrid frameworks",
-        "technical projects", "creative initiatives", "product launches",
-        "organizational change", "international teams", "startup environments",
-        "enterprise transformations"
-    ],
-    "startup_type": [
-        "tech", "social impact", "e-commerce", "healthcare", "education",
-        "fintech", "sustainability", "B2B SaaS", "consumer app", "AI/ML"
-    ],
-    "field": [
-        "Computer Science", "Business Administration", "Design", "Marketing",
-        "Engineering", "Data Science", "Psychology", "Communications",
-        "Information Technology", "Entrepreneurship"
-    ],
-    "university": [
-        "University of Toronto", "York University", "Ryerson University",
-        "Seneca College", "Humber College", "OCAD University",
-        "George Brown College", "McMaster University", "Waterloo University",
-        "Queen's University"
-    ],
-    "content_focus": [
-        "tech tutorials", "industry trends", "career development",
-        "product reviews", "educational content", "lifestyle and tech",
-        "startup stories", "coding challenges", "design inspiration",
-        "thought leadership"
-    ],
-    "sales_industry": [
-        "SaaS", "hardware", "consulting services", "enterprise solutions",
-        "consumer tech", "B2B technology", "telecommunications",
-        "cybersecurity", "cloud services", "digital transformation"
-    ],
-    "additional": [
-        "I'm excited to learn more about technology and how it can solve real problems.",
-        "I bring a unique perspective from my non-technical background.",
-        "I'm interested in the human aspects of technology.",
-        "I'm looking to collaborate with technical team members and contribute my skills.",
-        "I have strong communication and presentation skills.",
-        "I excel at understanding user needs and translating them into requirements.",
-        "I'm good at explaining complex concepts to diverse audiences.",
-        "I have experience managing stakeholder expectations.",
-        "I'm skilled at identifying market opportunities.",
-        "I enjoy bridging the gap between technical and non-technical teams.",
-        "I have a creative approach to problem-solving.",
-        "I'm passionate about user experience and accessibility.",
-        "I have a network of industry connections that could be valuable.",
-        "I'm experienced in gathering and synthesizing user feedback.",
-        "I'm interested in how technology can create social impact.",
-        "I have experience in project coordination and team organization.",
-        "I'm good at creating compelling narratives around technical products.",
-        "I'm curious about AI and its potential applications.",
-        "I have a background in psychology and understand human behavior.",
-        "I'm skilled at facilitating workshops and brainstorming sessions.",
-        "",  # Empty for some participants
-    ]
-}
-
-def generate_background(is_technical=True):
-    """Generate a realistic background for a participant."""
-    if is_technical:
-        template = random.choice(TECHNICAL_BACKGROUNDS)
-        components = STACK_COMPONENTS
-    else:
-        template = random.choice(NON_TECHNICAL_BACKGROUNDS)
-        components = NON_TECH_COMPONENTS
-    
-    # Fill in the template with random components
-    for key in components:
-        if "{" + key + "}" in template:
-            template = template.replace("{" + key + "}", random.choice(components[key]))
-    
-    return template
-
-def generate_linkedin_profile(name):
-    """Generate a realistic LinkedIn profile URL based on the name."""
-    # Remove spaces and special characters, convert to lowercase
-    name_part = ''.join(c for c in name if c.isalnum()).lower()
-    
-    # Add some randomness to ensure uniqueness
-    if random.random() < 0.3:
-        # Some people use just their name
-        profile = name_part
-    elif random.random() < 0.6:
-        # Some add a random number
-        profile = f"{name_part}{random.randint(1, 999)}"
-    else:
-        # Some add their profession or location
-        suffixes = ["dev", "tech", "to", "canada", "design", "pm", "product", "marketing", "ai"]
-        profile = f"{name_part}-{random.choice(suffixes)}"
-    
-    return f"linkedin.com/in/{profile}"
-
-def generate_participants(count=100):
-    """Generate a specified number of diverse hackathon participants."""
-    participants = []
-    
-    # Define the distribution of technical vs non-technical participants
-    # For a hackathon, we'll have more technical participants but still a good mix
-    technical_count = int(count * 0.7)  # 70% technical
-    non_technical_count = count - technical_count  # 30% non-technical
-    
-    # Generate technical participants
-    for _ in range(technical_count):
-        name = fake.name()
-        email = fake.email()
-        linkedin = generate_linkedin_profile(name)
-        background = generate_background(is_technical=True)
-        goals = random.choice(GOALS)
-        
-        participants.append({
-            "email": email,
-            "name": name,
-            "linkedin_profile": linkedin,
-            "background": background,
-            "goals": goals
-        })
-    
-    # Generate non-technical participants
-    for _ in range(non_technical_count):
-        name = fake.name()
-        email = fake.email()
-        linkedin = generate_linkedin_profile(name)
-        background = generate_background(is_technical=False)
-        goals = random.choice(GOALS)
-        
-        participants.append({
-            "email": email,
-            "name": name,
-            "linkedin_profile": linkedin,
-            "background": background,
-            "goals": goals
-        })
-    
-    # Shuffle the participants to mix technical and non-technical
-    random.shuffle(participants)
-    return participants
-
-def main():
-    """Main function to generate participants and save them to the database."""
-    print("Initializing database...")
-    initialize_database()
-    
-    print("Generating 100 diverse hackathon participants...")
-    participants = generate_participants(100)
-    
-    print("Adding participants to the database...")
-    for p in participants:
-        add_participant(p)
-    
-    print("Participants added successfully.")
-    
-    # Get and display a sample of the participants
-    df = get_participants_dataframe()
-    print(f"\nTotal participants in database: {len(df)}")
-    print("\nSample of participants:")
-    print(df.sample(5))
-
-if __name__ == "__main__":
-    # Check if Faker is installed
-    try:
-        import faker
-    except ImportError:
-        print("The 'faker' package is required but not installed.")
-        print("Please install it using: pip install faker")
-        sys.exit(1)
-    
-    main() 

hackathon_organizer/README.md

@@ -1,95 +0,0 @@
-# 🤖 AI-Powered HackBuddyAI
-
-This project is a web application that helps hackathon organizers automatically form balanced teams from a list of participants. It uses a `TinyCodeAgent` to analyze participant skills and goals, creating optimal teams based on criteria defined by the organizer.
-
-The application features a two-tab interface:
-1.  **Participant Registration**: A form for participants to submit their profile, including skills, background, and what they want to achieve during the hackathon.
-2.  **Organizer Dashboard**: A view for the organizer to see all registered participants, define matching criteria, and run the AI-powered team formation process.
-
-## Tech Stack
--   **Backend**: Python
--   **AI Agent Framework**: `TinyCodeAgent`
--   **Web UI**: Gradio
--   **Data Handling**: Pandas
--   **Database**: SQLite
-
----
-
-## Setup and Installation
-
-### 1. Prerequisites
--   Python 3.8+
--   An OpenAI API key
-
-### 2. Installation
-1.  **Clone the repository** (if applicable) or ensure you have the project files in a directory.
-
-2.  **Navigate to the project directory**:
-    ```bash
-    cd path/to/project
-    ```
-
-3.  **Create a virtual environment** (recommended):
-    ```bash
-    python -m venv venv
-    source venv/bin/activate  # On Windows, use `venv\Scripts\activate`
-    ```
-
-4.  **Install dependencies**:
-    The project relies on the `tinyagent` library. Assuming it is available in your environment, install the other required packages:
-    ```bash
-    pip install -r hackathon_organizer/requirements.txt
-    ```
-
-### 3. Configure Environment Variables
-You must set your OpenAI API key as an environment variable. The application will not run without it.
-
--   **On macOS/Linux**:
-    ```bash
-    export OPENAI_API_KEY="your_api_key_here"
-    ```
--   **On Windows (Command Prompt)**:
-    ```bash
-    set OPENAI_API_KEY="your_api_key_here"
-    ```
-
----
-
-## 🚀 Running the Application
-
-Once the setup is complete, you can launch the Gradio web application using one of the following methods:
-
-### Method 1: Using the main script (recommended)
-
-```bash
-python main.py
-```
-
-This script handles all the necessary path configurations and launches the application.
-
-### Method 2: Running app.py directly
-
-```bash
-cd hackathon_organizer
-python app.py
-```
-
-Either method will start a local web server, and you can access the application at the URL provided in the console (usually `http://127.0.0.1:7860`).
-
-The application will create a `hackathon_participants.db` file in the working directory to store the participant data.
-
----
-
-## 🧪 Running Tests
-
-The project includes unit tests for the database and the agent setup logic. The tests are located in the `tests/` directory.
-
-To run the tests:
-
-```bash
-# From the project root directory
-cd hackathon_organizer
-python -m unittest discover tests
-```
-
-The tests are designed to run without needing an active internet connection or a valid API key. They use mocks to simulate agent behavior and an in-memory database for testing database operations. 

hackathon_organizer/requirements.txt

@@ -1,7 +0,0 @@
-tinyagent-py[all]==0.0.12
-cloudpickle
-modal
-jinja2
-pyyaml
-gradio[mcp]
-pandas

main.py

@@ -1,52 +0,0 @@
-#!/usr/bin/env python3
-"""
-Hackathon Team Organizer - Main Entry Point
-
-This script launches the Hackathon Team Organizer application.
-It ensures the working directory is set correctly before running the app.
-"""
-import os
-import sys
-import subprocess
-
-def main():
-    # Get the directory where this script is located
-    script_dir = os.path.dirname(os.path.abspath(__file__))
-    
-    # Change to the script directory to ensure relative paths work
-    os.chdir(script_dir)
-    
-    # Add the current directory to the Python path
-    sys.path.insert(0, script_dir)
-    
-    print("Starting Hackathon Team Organizer...")
-    print(f"Working directory: {os.getcwd()}")
-    
-    # Check for OpenAI API key
-    if not os.environ.get("OPENAI_API_KEY"):
-        print("\n⚠️  WARNING: OPENAI_API_KEY environment variable is not set!")
-        print("The application requires an OpenAI API key to function properly.")
-        print("Please set it using:")
-        print("  export OPENAI_API_KEY='your-api-key'  (macOS/Linux)")
-        print("  set OPENAI_API_KEY='your-api-key'     (Windows)\n")
-        print("Running simplified version without AI matching...")
-        app_script = "hackathon_organizer/app_simple.py"
-    else:
-        print("OpenAI API key found. Running full version with AI matching...")
-        app_script = "hackathon_organizer/app.py"
-    
-    # Run the application
-    try:
-        print(f"Launching application: {app_script}")
-        subprocess.run([sys.executable, app_script], check=True)
-    except KeyboardInterrupt:
-        print("\nApplication stopped by user.")
-    except subprocess.CalledProcessError as e:
-        print(f"\nError running the application: {e}")
-        sys.exit(1)
-    except Exception as e:
-        print(f"\nUnexpected error: {e}")
-        sys.exit(1)
-
-if __name__ == "__main__":
-    main() 

notebook.ipynb

@@ -0,0 +1,112 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%load_ext autoreload\n",
+    "%autoreload 2\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import json\n",
+    "\n",
+    "import os\n",
+    "from dotenv import load_dotenv\n",
+    "import nest_asyncio\n",
+    "nest_asyncio.apply()\n",
+    "\n",
+    "# Load environment variables from a .env file\n",
+    "load_dotenv()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import tinyagent\n",
+    "from textwrap import dedent\n",
+    "import tinyagent.hooks\n",
+    "import tinyagent.hooks.rich_ui_callback\n",
+    "import tinyagent.mcp_client\n",
+    "import tinyagent.storage.json_file_storage\n",
+    "import tinyagent.storage.postgres_storage\n",
+    "import tinyagent.storage.sqlite_storage\n",
+    "from tinyagent import tool"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "SyntaxError",
+     "evalue": "invalid syntax (1561902338.py, line 1)",
+     "output_type": "error",
+     "traceback": [
+      "  \u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[5]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[31m    \u001b[39m\u001b[31mimport .create_matching_agent\u001b[39m\n           ^\n\u001b[31mSyntaxError\u001b[39m\u001b[31m:\u001b[39m invalid syntax\n"
+     ]
+    }
+   ],
+   "source": [
+    "import create_matching_agent"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3.11 (askdev_p311)",
+   "language": "python",
+   "name": "askdev_p311"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

product_manager/organizer.md

@@ -1,37 +0,0 @@
-
-#HackBuddyAI
-
-Gradio APP for Hackathon Organizer
-
-## Problem
-Many people join hackathons individually, and they need to be matched with other individuals to form a team. If the formed team is not suitable, non-of the team members will benefit from the hackathon, they will churn and not participate in the next hackathon.
-
-- Help individuals find the right team
-- If a selected team is not suitable, or some of participants didn't show up, the organizer could re-run the matching process to find a new team in no time.
-
-## Solution
-1. Web application for participants to fill their profile and goals, e_mail field to be used as a unique identifier, link to their linkedin profile, text field (multilined) for their background, skills, why they like to join the hackathon, etc.
-
-### 2. On form submission, the data will be stored in a database/ Google Sheet / SQLite
-
-### 3. Organizer part:
-Organizer could define custom system prompt, to navigate the system for matching the participants, for example group size, why organizer looks to have in each group, etc.
-
-### 4. Matching Proccess, 
-AI Agent, will have access to pandas dataframe, including the participants data and organizer prefrences for matching.
-It use its python code execution tool to actually interact with the data, and match the participants based on defined criteria.
-
-## End result
-List of teams with their members, and a short description why they are a good match. in Markdown format.
-
-
-## Tech Stack
-- Gradio
-- Tiny Agent
-- Tiny Code Agent
-- Pandas
-
-for developing the agent part we use tiny agent library, you have access to the documentation in the LLM_API_DOC.md file.
-
-For the frontend we use gradio, gradio has an integration with tiny agent as well. 
-

requirements.txt

@@ -3,4 +3,5 @@ cloudpickle
 modal
 jinja2
 pyyaml
-gradio[mcp]
+gradio[mcp]
+pandas

tests/test_database.py

@@ -0,0 +1,101 @@
+import unittest
+import os
+import pandas as pd
+import sys
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from database import initialize_database, add_participant, get_participants_dataframe
+
+# Use a separate test database
+TEST_DB_PATH = "test_hackathon.db"
+
+class TestDatabase(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        """Set up a test database before any tests run."""
+        cls.db_path = TEST_DB_PATH
+        # Point the database module to the test DB
+        import database
+        database.DB_PATH = cls.db_path
+
+    def setUp(self):
+        """Initialize a clean database before each test."""
+        if os.path.exists(self.db_path):
+            os.remove(self.db_path)
+        initialize_database()
+
+    def tearDown(self):
+        """Remove the database file after each test."""
+        if os.path.exists(self.db_path):
+            os.remove(self.db_path)
+
+    def test_01_initialize_database(self):
+        """Test that the database and table are created."""
+        self.assertTrue(os.path.exists(self.db_path))
+        df = get_participants_dataframe()
+        self.assertIsInstance(df, pd.DataFrame)
+        self.assertEqual(len(df), 0)
+
+    def test_02_add_and_get_participant(self):
+        """Test adding a single participant and retrieving it."""
+        participant = {
+            "email": "[email protected]",
+            "name": "Test User",
+            "linkedin_profile": "linkedin.com/in/test",
+            "background": "Testing background.",
+            "goals": "Testing goals."
+        }
+        add_participant(participant)
+
+        df = get_participants_dataframe()
+        self.assertEqual(len(df), 1)
+        
+        retrieved = df.iloc[0]
+        self.assertEqual(retrieved["email"], participant["email"])
+        self.assertEqual(retrieved["name"], participant["name"])
+
+    def test_03_add_multiple_participants(self):
+        """Test adding multiple participants."""
+        participants_to_add = [
+            {"email": "[email protected]", "name": "User One", "linkedin_profile": "", "background": "", "goals": ""},
+            {"email": "[email protected]", "name": "User Two", "linkedin_profile": "", "background": "", "goals": ""},
+        ]
+        for p in participants_to_add:
+            add_participant(p)
+
+        df = get_participants_dataframe()
+        self.assertEqual(len(df), 2)
+        self.assertIn("[email protected]", df["email"].values)
+        self.assertIn("[email protected]", df["email"].values)
+
+    def test_04_replace_participant(self):
+        """Test that adding a participant with an existing email updates the record."""
+        original_participant = {
+            "email": "[email protected]",
+            "name": "Original Name",
+            "linkedin_profile": "original_linkedin",
+            "background": "original_background",
+            "goals": "original_goals"
+        }
+        add_participant(original_participant)
+
+        df_before = get_participants_dataframe()
+        self.assertEqual(len(df_before), 1)
+        self.assertEqual(df_before.iloc[0]["name"], "Original Name")
+
+        updated_participant = {
+            "email": "[email protected]",
+            "name": "Updated Name",
+            "linkedin_profile": "updated_linkedin",
+            "background": "updated_background",
+            "goals": "updated_goals"
+        }
+        add_participant(updated_participant)
+
+        df_after = get_participants_dataframe()
+        self.assertEqual(len(df_after), 1)
+        self.assertEqual(df_after.iloc[0]["name"], "Updated Name")
+        self.assertEqual(df_after.iloc[0]["linkedin_profile"], "updated_linkedin")
+
+if __name__ == '__main__':
+    unittest.main() 

tests/test_matching_agent.py

@@ -0,0 +1,71 @@
+import unittest
+from unittest.mock import patch, MagicMock, AsyncMock
+import pandas as pd
+import os
+import sys
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from tinyagent import TinyCodeAgent
+from matching_agent import create_matching_agent, run_matching
+
+class TestMatchingAgent(unittest.TestCase):
+
+    @patch.dict(os.environ, {"OPENAI_API_KEY": "test_key"})
+    def test_01_create_matching_agent(self):
+        """
+        Test the creation and configuration of the matching agent.
+        """
+        agent = create_matching_agent()
+        
+        self.assertIsInstance(agent, TinyCodeAgent)
+        self.assertEqual(agent.model, "gpt-4.1-mini")
+        self.assertIn("You are a brilliant hackathon team-matching AI.", agent.system_prompt)
+        self.assertIn("participants_df", agent.system_prompt)
+        self.assertIn("organizer_criteria", agent.system_prompt)
+        
+        # Check code execution environment settings
+        self.assertIn("pandas", agent.pip_packages)
+        self.assertIn("scikit-learn", agent.pip_packages)
+        self.assertIn("pandas", agent.authorized_imports)
+
+    @patch.dict(os.environ, {"OPENAI_API_KEY": "test_key"})
+    def test_02_run_matching(self):
+        """
+        Test the run_matching function to ensure it configures the agent
+        and calls the run method correctly.
+        """
+        # Create a mock agent to isolate the test from the actual TinyCodeAgent implementation
+        mock_agent = MagicMock(spec=TinyCodeAgent)
+        mock_agent.run = AsyncMock(return_value="## Mocked Team Report")
+
+        # Sample data
+        participants_df = pd.DataFrame({
+            "name": ["Alice", "Bob"],
+            "skills": ["Frontend", "Backend"]
+        })
+        organizer_criteria = "Create teams of 2."
+
+        # Define an async test function to run the coroutine
+        async def do_run_matching():
+            result = await run_matching(mock_agent, participants_df, organizer_criteria)
+
+            # --- Assertions ---
+            # 1. Check that user_variables were set correctly on the agent
+            self.assertIn("participants_df", mock_agent.user_variables)
+            self.assertIn("organizer_criteria", mock_agent.user_variables)
+            pd.testing.assert_frame_equal(mock_agent.user_variables["participants_df"], participants_df)
+            self.assertEqual(mock_agent.user_variables["organizer_criteria"], organizer_criteria)
+
+            # 2. Check that agent.run was called correctly
+            mock_agent.run.assert_called_once()
+            # The first argument to run should be the user prompt
+            self.assertEqual(mock_agent.run.call_args[0][0], "Form the teams based on the provided data and criteria.")
+            
+            # 3. Check the result
+            self.assertEqual(result, "## Mocked Team Report")
+
+        # Run the async test function
+        import asyncio
+        asyncio.run(do_run_matching())
+
+if __name__ == '__main__':
+    unittest.main()