From e8c4bb119553337e260182c0558931e2373d41a6 Mon Sep 17 00:00:00 2001
From: Zaid Ahmad <109442753+zaidahmad16@users.noreply.github.com>
Date: Tue, 26 May 2026 15:02:25 -0400
Subject: [PATCH] feat: add professor info and RMP ratings to course panel

When a student clicks a course node, the panel now shows which
professors are teaching it in Fall 2026 and Winter 2027, along
with their RateMyProfessors rating, difficulty, and "would take
again" percentage pulled live via ratemyprofessors-client.

- backend/timetable_scraper.py: scrapes Carleton Central for both
  terms and populates a new course_instructors table in Neon
- GET /courses/{code}/instructors: new endpoint returning
  instructors grouped by term
- frontend/app/api/rmp/route.js: Next.js API route that queries
  RMP for a professor by name, scoped to Carleton (school ID 1420),
  with in-memory caching
- CoursePanel.jsx: shows instructor cards with color-coded rating,
  difficulty, take-again %, and a link to their RMP profile
---
 backend/main.py                             |  29 +++
 backend/timetable_scraper.py                | 192 ++++++++++++++++++++
 frontend/app/api/rmp/route.js               |  46 +++++
 frontend/app/map/components/CoursePanel.jsx | 180 +++++++++++++++++-
 frontend/package-lock.json                  |  22 +++
 frontend/package.json                       |   1 +
 6 files changed, 468 insertions(+), 2 deletions(-)
 create mode 100644 backend/timetable_scraper.py
 create mode 100644 frontend/app/api/rmp/route.js

diff --git a/backend/main.py b/backend/main.py
index f827449..b15c237 100644
--- a/backend/main.py
+++ b/backend/main.py
@@ -405,6 +405,35 @@ def get_courses_batch(request: Request, codes: List[str]):
     finally:
         conn.close()
 
+@app.get("/courses/{course_code}/instructors")
+@limiter.limit("60/minute")
+def get_course_instructors(request: Request, course_code: str):
+    code = course_code.upper().replace("-", " ")
+    if not COURSE_CODE_RE.match(code):
+        raise HTTPException(status_code=400, detail="Invalid course code")
+    conn = get_connection()
+    try:
+        cur = conn.cursor()
+        cur.execute("""
+            SELECT DISTINCT term, instructor_name
+            FROM course_instructors
+            WHERE course_code = %s
+            ORDER BY term, instructor_name
+        """, (code,))
+        rows = cur.fetchall()
+        cur.close()
+        # Group by term
+        terms: dict = {}
+        for term, name in rows:
+            terms.setdefault(term, []).append(name)
+        return [{"term": t, "instructors": names} for t, names in terms.items()]
+    except Exception as e:
+        logger.error("GET /courses/%s/instructors failed: %s", course_code, e, exc_info=True)
+        raise HTTPException(status_code=500, detail="Internal server error")
+    finally:
+        conn.close()
+
+
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=8000)
diff --git a/backend/timetable_scraper.py b/backend/timetable_scraper.py
new file mode 100644
index 0000000..83779c0
--- /dev/null
+++ b/backend/timetable_scraper.py
@@ -0,0 +1,192 @@
+"""
+Scrapes Carleton Central timetable for instructor names per course per term.
+Populates the course_instructors table.
+
+Usage: python3 timetable_scraper.py
+"""
+
+import os, re, time, requests
+from psycopg2.extras import execute_values
+from db import get_connection
+from dotenv import load_dotenv
+
+load_dotenv()
+
+BASE_URL = "https://central.carleton.ca/prod"
+TERMS = [
+    ("202630", "Fall 2026"),
+    ("202710", "Winter 2027"),
+]
+
+# All undergrad subject codes we care about (pulled from the search page)
+def get_subject_codes(session: requests.Session, term_code: str, session_id: str) -> list[str]:
+    resp = session.post(f"{BASE_URL}/bwysched.p_search_fields", data={
+        "wsea_code": "EXT",
+        "term_code": term_code,
+        "session_id": session_id,
+    })
+    return re.findall(r'<option value="([A-Z]{2,5})"', resp.text)
+
+
+def get_session_id(session: requests.Session, term_code: str) -> str:
+    resp = session.get(f"{BASE_URL}/bwysched.p_select_term?wsea_code=EXT")
+    sid = re.search(r'session_id" value="(\d+)"', resp.text)
+    if not sid:
+        raise RuntimeError("Could not get session_id")
+    # Now post the term selection to advance the session
+    session.post(f"{BASE_URL}/bwysched.p_search_fields", data={
+        "wsea_code": "EXT",
+        "term_code": term_code,
+        "session_id": sid.group(1),
+    })
+    return sid.group(1)
+
+
+DUMMY_FIELDS = {
+    "sel_aud": "dummy", "sel_subj": "dummy", "sel_camp": "dummy",
+    "sel_sess": "dummy", "sel_attr": "dummy", "sel_levl": "dummy",
+    "sel_schd": "dummy", "sel_insm": "dummy", "sel_link": "dummy",
+    "sel_wait": "dummy", "sel_day": "dummy", "sel_begin_hh": "dummy",
+    "sel_begin_mi": "dummy", "sel_begin_am_pm": "dummy",
+    "sel_end_hh": "dummy", "sel_end_mi": "dummy",
+    "sel_end_am_pm": "dummy", "sel_instruct": "dummy",
+    "sel_special": "dummy", "sel_resd": "dummy", "sel_breadth": "dummy",
+}
+
+DAY_FIELDS = {
+    "sel_day": ["m", "t", "w", "r", "f", "s"],
+    "sel_begin_hh": "0", "sel_begin_mi": "0", "sel_begin_am_pm": "a",
+    "sel_end_hh": "23", "sel_end_mi": "59", "sel_end_am_pm": "p",
+    "sel_levl": "UG",
+}
+
+
+def parse_instructors(html: str, subj: str, term_label: str) -> list[tuple]:
+    """
+    Returns list of (course_code, term, instructor_name) tuples.
+    Only includes Lecture/Seminar rows to avoid duplicating per tutorial section.
+    """
+    results = []
+    seen = set()
+    for row in re.split(r'<tr\b', html):
+        code_m = re.search(rf'{re.escape(subj)}\s+(\d{{4}}[A-Z]?)</font>', row)
+        type_m = re.search(r'<td[^>]*>(Lecture|Seminar)</td>', row)
+        if not code_m or not type_m:
+            continue
+        # Instructor is the last plain-text td (no href inside)
+        plain_tds = re.findall(r'<td[^>]*>\s*([A-Za-z][^<\n]{2,50}?)\s*</td>', row)
+        if not plain_tds:
+            continue
+        instructor = plain_tds[-1].strip()
+        if not instructor or '&nbsp;' in instructor or instructor.lower() in (
+            'tba', 'staff', 'lecture', 'tutorial', 'lab', 'seminar', 'yes', 'no', 'open', 'closed'
+        ):
+            continue
+        code = f"{subj} {code_m.group(1)}"
+        key = (code, term_label, instructor)
+        if key not in seen:
+            seen.add(key)
+            results.append(key)
+    return results
+
+
+def scrape_subject(session: requests.Session, term_code: str, term_label: str,
+                   session_id: str, subj: str) -> list[tuple]:
+    data = {
+        "wsea_code": "EXT",
+        "term_code": term_code,
+        "session_id": session_id,
+        "ws_numb": "",
+        **DUMMY_FIELDS,
+        "sel_subj": subj,
+        "sel_number": "",
+        **DAY_FIELDS,
+    }
+    # requests doesn't handle repeated keys well with dict; use list of tuples
+    payload = []
+    for k, v in data.items():
+        if isinstance(v, list):
+            for item in v:
+                payload.append((k, item))
+        else:
+            payload.append((k, v))
+    # Add the multi-value day fields correctly
+    payload = [
+        ("wsea_code", "EXT"), ("term_code", term_code), ("session_id", session_id),
+        ("ws_numb", ""), ("sel_aud", "dummy"), ("sel_subj", "dummy"),
+        ("sel_camp", "dummy"), ("sel_sess", "dummy"), ("sel_attr", "dummy"),
+        ("sel_levl", "dummy"), ("sel_schd", "dummy"), ("sel_insm", "dummy"),
+        ("sel_link", "dummy"), ("sel_wait", "dummy"), ("sel_day", "dummy"),
+        ("sel_begin_hh", "dummy"), ("sel_begin_mi", "dummy"),
+        ("sel_begin_am_pm", "dummy"), ("sel_end_hh", "dummy"),
+        ("sel_end_mi", "dummy"), ("sel_end_am_pm", "dummy"),
+        ("sel_instruct", "dummy"), ("sel_special", "dummy"),
+        ("sel_resd", "dummy"), ("sel_breadth", "dummy"),
+        ("sel_subj", subj), ("sel_number", ""),
+        ("sel_day", "m"), ("sel_day", "t"), ("sel_day", "w"),
+        ("sel_day", "r"), ("sel_day", "f"), ("sel_day", "s"),
+        ("sel_begin_hh", "0"), ("sel_begin_mi", "0"), ("sel_begin_am_pm", "a"),
+        ("sel_end_hh", "23"), ("sel_end_mi", "59"), ("sel_end_am_pm", "p"),
+        ("sel_levl", "UG"),
+    ]
+    resp = session.post(f"{BASE_URL}/bwysched.p_course_search", data=payload)
+    return parse_instructors(resp.text, subj, term_label)
+
+
+def create_table(conn):
+    with conn.cursor() as cur:
+        cur.execute("""
+            CREATE TABLE IF NOT EXISTS course_instructors (
+                id SERIAL PRIMARY KEY,
+                course_code TEXT NOT NULL,
+                term TEXT NOT NULL,
+                instructor_name TEXT NOT NULL,
+                UNIQUE(course_code, term, instructor_name)
+            )
+        """)
+    conn.commit()
+
+
+def upsert_rows(conn, rows: list[tuple]):
+    if not rows:
+        return
+    with conn.cursor() as cur:
+        execute_values(cur, """
+            INSERT INTO course_instructors (course_code, term, instructor_name)
+            VALUES %s
+            ON CONFLICT (course_code, term, instructor_name) DO NOTHING
+        """, rows)
+    conn.commit()
+
+
+def main():
+    conn = get_connection()
+    create_table(conn)
+
+    http = requests.Session()
+    http.headers.update({"User-Agent": "CarletonCourseMap/1.0 (student project)"})
+
+    total = 0
+    for term_code, term_label in TERMS:
+        print(f"\n=== {term_label} ===")
+        session_id = get_session_id(http, term_code)
+        subjects = get_subject_codes(http, term_code, session_id)
+        print(f"Found {len(subjects)} subjects")
+
+        for subj in subjects:
+            try:
+                rows = scrape_subject(http, term_code, term_label, session_id, subj)
+                if rows:
+                    upsert_rows(conn, rows)
+                    print(f"  {subj}: {len(rows)} sections")
+                    total += len(rows)
+                time.sleep(0.4)  # be polite
+            except Exception as e:
+                print(f"  {subj}: ERROR {e}")
+
+    conn.close()
+    print(f"\nDone. {total} total rows inserted.")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/frontend/app/api/rmp/route.js b/frontend/app/api/rmp/route.js
new file mode 100644
index 0000000..715ce6f
--- /dev/null
+++ b/frontend/app/api/rmp/route.js
@@ -0,0 +1,46 @@
+import { RMPClient } from 'ratemyprofessors-client'
+import { NextResponse } from 'next/server'
+
+const CARLETON_SCHOOL_ID = '1420'
+const client = new RMPClient()
+
+// Cache results in memory for the lifetime of the server process
+const cache = new Map()
+
+export async function GET(request) {
+  const { searchParams } = new URL(request.url)
+  const name = searchParams.get('name')?.trim()
+
+  if (!name) {
+    return NextResponse.json({ error: 'name is required' }, { status: 400 })
+  }
+
+  if (cache.has(name)) {
+    return NextResponse.json(cache.get(name))
+  }
+
+  try {
+    const result = await client.searchProfessors(name, CARLETON_SCHOOL_ID)
+    // Pick the first result that belongs to Carleton
+    const prof = result.professors?.find(p => p.school?.id === CARLETON_SCHOOL_ID) ?? null
+
+    const data = prof
+      ? {
+          found: true,
+          name: prof.name,
+          department: prof.department,
+          overall_rating: prof.overall_rating,
+          difficulty: prof.level_of_difficulty,
+          num_ratings: prof.num_ratings,
+          would_take_again: prof.percent_take_again >= 0 ? Math.round(prof.percent_take_again) : null,
+          rmp_url: `https://www.ratemyprofessors.com/professor/${prof.id}`,
+        }
+      : { found: false }
+
+    cache.set(name, data)
+    return NextResponse.json(data)
+  } catch (err) {
+    console.error('RMP lookup failed for', name, err)
+    return NextResponse.json({ found: false })
+  }
+}
diff --git a/frontend/app/map/components/CoursePanel.jsx b/frontend/app/map/components/CoursePanel.jsx
index b331563..783f991 100644
--- a/frontend/app/map/components/CoursePanel.jsx
+++ b/frontend/app/map/components/CoursePanel.jsx
@@ -1,12 +1,62 @@
+'use client'
+
 /* course detail panel — right sidebar on desktop, bottom drawer on mobile */
 
+import { useState, useEffect } from 'react'
+
+const API = process.env.NEXT_PUBLIC_API_URL || 'http://localhost:8000'
+
 export const CoursePanel = ({ node, onClose, isMobile }) => {
   const isOpen = node != null && !node.data?.isElective
 
-
   const { code, name, description, credit, prerequisites, offerings } =
     isOpen ? node.data : {}
 
+  const [instructorData, setInstructorData] = useState(null) // [{term, instructors: [{name, rmp}]}]
+  const [loadingInstructors, setLoadingInstructors] = useState(false)
+
+  useEffect(() => {
+    if (!isOpen || !code) {
+      setInstructorData(null)
+      return
+    }
+    setInstructorData(null)
+    setLoadingInstructors(true)
+
+    const encodedCode = code.replace(' ', '-')
+
+    fetch(`${API}/courses/${encodedCode}/instructors`)
+      .then(r => r.json())
+      .then(async termGroups => {
+        if (!termGroups.length) {
+          setInstructorData([])
+          setLoadingInstructors(false)
+          return
+        }
+        // For each unique instructor, fetch RMP data
+        const allNames = [...new Set(termGroups.flatMap(g => g.instructors))]
+        const rmpMap = {}
+        await Promise.all(allNames.map(async name => {
+          try {
+            const res = await fetch(`/api/rmp?name=${encodeURIComponent(name)}`)
+            rmpMap[name] = await res.json()
+          } catch {
+            rmpMap[name] = { found: false }
+          }
+        }))
+        const enriched = termGroups.map(g => ({
+          term: g.term,
+          instructors: g.instructors.map(n => ({ name: n, rmp: rmpMap[n] ?? { found: false } })),
+        }))
+        setInstructorData(enriched)
+        setLoadingInstructors(false)
+      })
+      .catch(() => {
+        setInstructorData([])
+        setLoadingInstructors(false)
+      })
+  }, [code, isOpen])
+
   const panelStyle = isMobile
     ? isOpen
       ? {
@@ -43,7 +93,7 @@ export const CoursePanel = ({ node, onClose, isMobile }) => {
     ? {
         bottom: 0, left: 0, right: 0,
         width: '100%',
-        height: '65vh',
+        height: '75vh',
         borderRadius: '12px 12px 0 0',
         borderTop: '1px solid var(--color-rule)',
       }
@@ -181,12 +231,138 @@ export const CoursePanel = ({ node, onClose, isMobile }) => {
               <div style={bodyText}>{prerequisites}</div>
             </div>
           )}
+
+          {/* Instructors */}
+          <div style={{ marginBottom: 'var(--space-md)' }}>
+            <SectionLabel>Instructors (2026–2027)</SectionLabel>
+            {loadingInstructors && (
+              <div style={{ ...bodyText, color: 'var(--color-ink-3)' }}>Loading…</div>
+            )}
+            {!loadingInstructors && instructorData && instructorData.length === 0 && (
+              <div style={{ ...bodyText, color: 'var(--color-ink-3)' }}>No timetable data yet</div>
+            )}
+            {!loadingInstructors && instructorData && instructorData.map(group => (
+              <div key={group.term} style={{ marginBottom: 'var(--space-sm)' }}>
+                <div style={{
+                  fontSize: 'var(--text-xs)',
+                  fontWeight: 600,
+                  color: 'var(--color-ink-3)',
+                  marginBottom: 6,
+                }}>
+                  {group.term}
+                </div>
+                {group.instructors.map(({ name: profName, rmp }) => (
+                  <ProfCard key={profName} name={profName} rmp={rmp} />
+                ))}
+              </div>
+            ))}
+          </div>
+
         </div>
       </div>
     </>
   )
 }
 
+const ProfCard = ({ name, rmp }) => (
+  <div style={{
+    background: 'var(--color-paper-2)',
+    border: '1px solid var(--color-rule)',
+    borderRadius: 8,
+    padding: '10px 12px',
+    marginBottom: 8,
+  }}>
+    <div style={{
+      display: 'flex',
+      justifyContent: 'space-between',
+      alignItems: 'flex-start',
+      gap: 8,
+    }}>
+      <span style={{
+        fontSize: 'var(--text-sm)',
+        fontWeight: 600,
+        color: 'var(--color-ink)',
+        lineHeight: 1.3,
+      }}>
+        {name}
+      </span>
+      {rmp?.found && (
+        <a
+          href={rmp.rmp_url}
+          target="_blank"
+          rel="noopener noreferrer"
+          style={{
+            fontSize: 'var(--text-xs)',
+            color: 'var(--color-accent)',
+            textDecoration: 'none',
+            whiteSpace: 'nowrap',
+            flexShrink: 0,
+          }}
+        >
+          RMP ↗
+        </a>
+      )}
+    </div>
+
+    {rmp?.found ? (
+      <div style={{
+        display: 'flex',
+        gap: 'var(--space-sm)',
+        marginTop: 6,
+        flexWrap: 'wrap',
+      }}>
+        <RmpStat label="Rating" value={rmp.overall_rating?.toFixed(1)} outOf={5} color={ratingColor(rmp.overall_rating)} />
+        <RmpStat label="Difficulty" value={rmp.difficulty?.toFixed(1)} outOf={5} color={difficultyColor(rmp.difficulty)} />
+        {rmp.would_take_again != null && (
+          <RmpStat label="Take again" value={`${rmp.would_take_again}%`} />
+        )}
+        <span style={{
+          fontSize: 'var(--text-xs)',
+          color: 'var(--color-ink-3)',
+          alignSelf: 'flex-end',
+        }}>
+          {rmp.num_ratings} rating{rmp.num_ratings !== 1 ? 's' : ''}
+        </span>
+      </div>
+    ) : (
+      <div style={{
+        fontSize: 'var(--text-xs)',
+        color: 'var(--color-ink-3)',
+        marginTop: 4,
+      }}>
+        Not on RateMyProfessors
+      </div>
+    )}
+  </div>
+)
+
+const RmpStat = ({ label, value, color }) => (
+  <div style={{ display: 'flex', flexDirection: 'column', gap: 1 }}>
+    <span style={{ fontSize: 'var(--text-xs)', color: 'var(--color-ink-3)' }}>{label}</span>
+    <span style={{
+      fontSize: 'var(--text-sm)',
+      fontWeight: 700,
+      color: color ?? 'var(--color-ink)',
+    }}>
+      {value ?? '—'}
+    </span>
+  </div>
+)
+
+function ratingColor(r) {
+  if (r == null) return 'var(--color-ink)'
+  if (r >= 4) return '#2d9e5f'
+  if (r >= 3) return '#d97706'
+  return '#dc2626'
+}
+
+function difficultyColor(d) {
+  if (d == null) return 'var(--color-ink)'
+  if (d <= 2.5) return '#2d9e5f'
+  if (d <= 3.5) return '#d97706'
+  return '#dc2626'
+}
+
 const chipStyle = {
   background: 'var(--color-paper-2)',
   border: '1px solid var(--color-rule)',
diff --git a/frontend/package-lock.json b/frontend/package-lock.json
index 1792251..c55d369 100644
--- a/frontend/package-lock.json
+++ b/frontend/package-lock.json
@@ -15,6 +15,7 @@
         "dagre": "^0.8.5",
         "next": "16.2.6",
         "postcss": "^8.5.15",
+        "ratemyprofessors-client": "^3.0.0",
         "react": "19.2.4",
         "react-dom": "19.2.4",
         "reactflow": "^11.11.4",
@@ -6469,6 +6470,18 @@
       ],
       "license": "MIT"
     },
+    "node_modules/ratemyprofessors-client": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/ratemyprofessors-client/-/ratemyprofessors-client-3.0.0.tgz",
+      "integrity": "sha512-9rDnuEsxFyL0cXFDGHmS0ZBE6v8X0JuDjauwr7F28XJ8IjtsJ9F4S20S5AOAqcIn7NNtx08vyfYS58njAi9YZw==",
+      "license": "MIT",
+      "dependencies": {
+        "sentiment": "^5.0.2"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/react": {
       "version": "19.2.4",
       "resolved": "https://registry.npmjs.org/react/-/react-19.2.4.tgz",
@@ -6734,6 +6747,15 @@
         "semver": "bin/semver.js"
       }
     },
+    "node_modules/sentiment": {
+      "version": "5.0.2",
+      "resolved": "https://registry.npmjs.org/sentiment/-/sentiment-5.0.2.tgz",
+      "integrity": "sha512-ZeC3y0JsOYTdwujt5uOd7ILJNilbgFzUtg/LEG4wUv43LayFNLZ28ec8+Su+h3saHlJmIwYxBzfDHHZuiMA15g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8.0"
+      }
+    },
     "node_modules/set-function-length": {
       "version": "1.2.2",
       "resolved": "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz",
diff --git a/frontend/package.json b/frontend/package.json
index d9ac081..4ed6148 100644
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -16,6 +16,7 @@
     "dagre": "^0.8.5",
     "next": "16.2.6",
     "postcss": "^8.5.15",
+    "ratemyprofessors-client": "^3.0.0",
     "react": "19.2.4",
     "react-dom": "19.2.4",
     "reactflow": "^11.11.4",