Skill: aipoch-ai/conference-schedule-optimizer (version 0.1.0)

--- name: conference-schedule-optimizer description: Use when planning conference schedules, optimizing session selection at scientific meetings, managing time between presentations, or maximizing networking at academic conferences. Creates personalized schedules balancing learning, networking, and career development for medical and scientific conferences. allowed-tools: "Read Write Bash Edit" license: MIT metadata: skill-author: AIPOCH version: "1.0" --- # Conference Schedule Optimizer Create optimal conference schedules balancing learning, networking, and career development for scientific and medical conferences. ## Quick Start ```python from scripts.schedule_optimizer import ConferenceScheduler scheduler = ConferenceScheduler() # Generate optimized schedule schedule = scheduler.optimize( conference="ASHG2024", interests=["genomics", "bioinformatics", "rare diseases"], constraints={"avoid_mornings": True, "networking_priority": "high"} ) # Export to calendar scheduler.export(schedule, format="ical", filename="my_conference.ics") ``` ## Core Capabilities ### 1. Session Prioritization ```python priorities = scheduler.prioritize_sessions( sessions=conference_sessions, criteria={ "topic_relevance": 0.35, "speaker_reputation": 0.25, "career_value": 0.20, "networking_opportunity": 0.20 } ) ``` **Prioritization Matrix:** | Factor | Weight | How Measured | |--------|--------|--------------| | Topic Relevance | 35% | Keyword matching with your research | | Speaker Impact | 25% | Citation count, h-index, previous talks | | Career Value | 20% | Job opportunities, collaborations | | Networking | 20% | Attendee overlap, social events | ### 2. Schedule Optimization ```python optimized_schedule = scheduler.create_schedule( sessions=priorities, constraints={ "max_consecutive_sessions": 3, "lunch_break": "12:00-13:00", "must_attend": ["Keynote: Dr. Smith", "Workshop: CRISPR"], "avoid": ["conflict_of_interest_sessions"] } ) ``` ### 3. Conflict Resolution ```python resolved = scheduler.resolve_conflicts( overlapping_sessions=[session_a, session_b], strategy="attend_record_delegate" ) ``` **Conflict Resolution Strategies:** | Strategy | Best For | Implementation | |----------|----------|----------------| | Attend + Record | High-priority talk | Attend live, watch recording later | | Split Time | Equal priority | 20 min each, network after | | Delegate | Team attending | Colleague attends, shares notes | | Poster Alternative | Overlapping talks | Visit presenter's poster session | ### 4. Networking Planner ```python networking_blocks = scheduler.plan_networking( target_attendees=[ {"name": "Dr. Smith", "institution": "Stanford", "topic": "Genomics"}, {"name": "Prof. Johnson", "institution": "Broad", "topic": "CRISPR"} ], strategy="coffee_chats", buffer_minutes=15 ) ``` **Networking Tactics:** - **Coffee Chats**: Schedule 15-min meetings before/after sessions - **Poster Sessions**: High-quality conversations in relaxed setting - **Social Events**: Evening receptions for informal networking - **Twitter/X**: Live-tweet to connect with remote attendees ### 5. Travel Time Calculator ```python schedule_with_travel = scheduler.add_travel_time( base_schedule, venue_map="conference_center.pdf", walking_speed="normal", # or "slow" with poster tubes buffer_percent=20 ) ``` ## CLI Usage ```bash # Optimize from conference program PDF python scripts/schedule_optimizer.py \ --program ashg2024_program.pdf \ --interests "genomics,bioinformatics,ethics" \ --constraints "no_mornings,prefer_posters" \ --output my_schedule.ics # Real-time update with room changes python scripts/schedule_optimizer.py \ --conference ASHG2024 \ --update --notify # Generate networking targets python scripts/schedule_optimizer.py \ --conference ASHG2024 \ --mode networking \ --my-research "rare disease genomics" \ --output targets.csv ``` ## Common Patterns ### Pattern 1: First-Time Attendee **Goal**: Maximize learning, minimize overwhelm ```python schedule = scheduler.optimize( conference="ISMRM2024", experience_level="first_time", strategy="breadth_over_depth", include_tutorials=True, social_events_priority="high" ) ``` ### Pattern 2: Job Seeker **Goal**: Network with target institutions ```python schedule = scheduler.optimize( conference="SFN2024", goals=["job_search", "networking"], target_institutions=["NIH", "Stanford", "Genentech"], career_sessions_priority="must_attend" ) ``` ### Pattern 3: Poster Presenter **Goal**: Balance presenting with attending ```python schedule = scheduler.optimize( conference="AGU2024", my_poster_session="Tuesday 2-4pm", conflicts_strategy="skip_lower_priority", networking_during_poster=True ) ``` ## Quality Checklist **Pre-Conference (2 weeks before):** - [ ] Download conference app/program - [ ] Flag 3 "must-attend" sessions per day - [ ] Identify 5-10 people to meet - [ ] Schedule non-conference meetings outside conference hours - [ ] Download and review key papers from speakers **During Conference:** - [ ] Check schedule each morning for updates - [ ] Take notes in unified location (app or notebook) - [ ] Block 30-min daily for exhibit hall - [ ] Stay hydrated and take walking breaks - [ ] Tweet key insights (tag speakers, use conference hashtag) **Post-Conference (within 48 hours):** - [ ] Email new contacts with specific follow-up - [ ] Organize notes by actionable items - [ ] Share key learnings with lab/team - [ ] Update CV with conference activities ## Common Pitfalls ❌ **Over-scheduling**: No breaks between sessions ✅ **Buffer time**: 15-min gaps for transitions and networking ❌ **Session hopping**: Leaving talks early ✅ **Commit fully**: Attend entire session or don't go ❌ **Skipping meals**: Running from session to session ✅ **Scheduled breaks**: Block lunch, rest, and processing time --- **Skill ID**: 206 | **Version**: 1.0 | **License**: MIT

path: scripts/main.py
content: #!/usr/bin/env python3
"""
Conference Schedule Optimizer
Optimize conference attendance schedule.
"""

import argparse
import json
from datetime import datetime


class ScheduleOptimizer:
    """Optimize conference schedule."""
    
    def __init__(self):
        self.schedule = []
        self.interests = []
    
    def load_schedule(self, schedule_file):
        """Load conference schedule."""
        with open(schedule_file) as f:
            data = json.load(f)
        return data.get("sessions", [])
    
    def score_session(self, session, interests):
        """Score session relevance to interests."""
        score = 0
        session_topics = session.get("topics", [])
        session_title = session.get("title", "").lower()
        
        for interest in interests:
            interest = interest.lower().strip()
            if interest in session_title:
                score += 10
            for topic in session_topics:
                if interest in topic.lower():
                    score += 5
        
        return score
    
    def find_conflicts(self, sessions):
        """Find time conflicts."""
        conflicts = []
        for i, s1 in enumerate(sessions):
            for s2 in sessions[i+1:]:
                if s1["start"] == s2["start"]:
                    conflicts.append((s1, s2))
        return conflicts
    
    def optimize(self, sessions, interests, must_attend=None):
        """Generate optimized schedule."""
        must_attend = must_attend or []
        
        # Score all sessions
        scored = []
        for session in sessions:
            score = self.score_session(session, interests)
            is_must = session.get("id") in must_attend
            scored.append({
                **session,
                "score": score,
                "is_must": is_must
            })
        
        # Sort by time, then by score (must-attend first)
        scored.sort(key=lambda x: (x["start"], not x["is_must"], -x["score"]))
        
        # Select non-conflicting sessions
        selected = []
        used_times = set()
        
        for session in scored:
            if session["is_must"] or session["start"] not in used_times:
                selected.append(session)
                used_times.add(session["start"])
        
        return selected
    
    def print_schedule(self, schedule):
        """Print optimized schedule."""
        print("\n" + "="*70)
        print("OPTIMIZED CONFERENCE SCHEDULE")
        print("="*70)
        
        current_day = None
        for session in schedule:
            day = session["start"][:10]
            if day != current_day:
                current_day = day
                print(f"\n📅 {day}")
                print("-"*70)
            
            must = "⭐ " if session["is_must"] else "   "
            print(f"{must}{session['start'][11:16]} - {session['title'][:50]}")
            print(f"    Room: {session.get('room', 'TBA')} | Score: {session['score']}")
        
        print("="*70 + "\n")


def main():
    parser = argparse.ArgumentParser(description="Conference Schedule Optimizer")
    parser.add_argument("--interests", "-i", required=True,
                       help="Comma-separated topic interests")
    parser.add_argument("--schedule", "-s", required=True,
                       help="Conference schedule JSON file")
    parser.add_argument("--must-attend", "-m",
                       help="Comma-separated must-attend session IDs")
    parser.add_argument("--output", "-o", help="Output file")
    
    args = parser.parse_args()
    
    optimizer = ScheduleOptimizer()
    
    # Load and process
    sessions = optimizer.load_schedule(args.schedule)
    interests = [i.strip() for i in args.interests.split(",")]
    must_attend = [m.strip() for m in args.must_attend.split(",")] if args.must_attend else []
    
    # Optimize
    optimized = optimizer.optimize(sessions, interests, must_attend)
    
    # Display
    optimizer.print_schedule(optimized)
    
    # Save if requested
    if args.output:
        with open(args.output, 'w') as f:
            json.dump(optimized, f, indent=2)
        print(f"Saved to: {args.output}")


if __name__ == "__main__":
    main()


path: tile.json
content: {
  "name": "aipoch/conference-schedule-optimizer",
  "version": "0.1.0",
  "private": true,
  "summary": "Use when planning conference schedules, optimizing session selection, managing time between presentations, or networking at academic conferences.",
  "skills": {
    "conference-schedule-optimizer": {
      "path": "SKILL.md"
    }
  }
}


Security scan verdicts — ClawScan: clean | static analysis: clean | VirusTotal: clean | SkillSpector: clean (LOW)