Skip to content
TheChatArchiveThe Chat Archive
Grok 4.1 Fast· xaiHugging Face Frontier Reasoning Traces

Build a registrar API for degree audit integrations.

  1. User

    Build a registrar API for degree audit integrations.

  2. Assistant
    """
    Registrar API for Degree Audit Integrations
    
    This is a fully functional REST API built with FastAPI (Python) for registrar operations focused on degree audits.
    It supports:
    - Student profiles and completed courses.
    - Degree/program requirements (credits, required courses).
    - Running degree audits to compute progress, fulfillment status, and gaps.
    
    Key Features:
    - RESTful endpoints.
    - Automatic OpenAPI/Swagger docs at /docs.
    - In-memory data store (for demo; easily swap with PostgreSQL/SQLAlchemy).
    - Extensible audit logic: Checks total credits, specific required courses, and elective credits.
    - JSON responses with clear schemas.
    
    Run with: pip install fastapi uvicorn pydantic
              uvicorn main:app --reload
    """
    
    from typing import List, Dict, Any, Optional
    from enum import Enum
    from pydantic import BaseModel
    from fastapi import FastAPI, HTTPException, Path, Query
    from fastapi.responses import JSONResponse
    import uvicorn
    
    app = FastAPI(
        title="Registrar API for Degree Audit Integrations",
        description="API for querying student data and running degree audits.",
        version="1.0.0"
    )
    
    # Enums
    class Grade(str, Enum):
        A = "A"
        B = "B"
        C = "C"
        D = "D"
        F = "F"
        P = "P"  # Pass
        IP = "IP"  # In Progress
    
    class CourseStatus(str, Enum):
        COMPLETED = "completed"
        IN_PROGRESS = "in_progress"
    
    # Pydantic Models
    class Course(BaseModel):
        course_id: str
        title: str
        credits: float
        grade: Optional[Grade] = None
        status: CourseStatus = CourseStatus.COMPLETED
    
    class Student(BaseModel):
        student_id: str
        name: str
        email: str
        enrolled_degree_id: Optional[str] = None
    
    class DegreeRequirement(BaseModel):
        degree_id: str
        name: str
        total_credits_required: float
        required_courses: List[str]  # e.g., ["MATH101", "CS201"]
        elective_credits_required: float = 0.0
    
    class AuditRequest(BaseModel):
        student_id: str
        degree_id: str
    
    class AuditResult(BaseModel):
        student_id: str
        degree_id: str
        degree_name: str
        total_credits_required: float
        completed_credits: float
        elective_credits_used: float
        required_courses: List[str]
        fulfilled_required_courses: List[str]
        missing_required_courses: List[str]
        is_graduation_ready: bool
        notes: List[str]
    
    # In-Memory Data Store (Replace with DB in production)
    students: Dict[str, Student] = {
        "S001": Student(student_id="S001", name="John Doe", email="john@example.com", enrolled_degree_id="BS-CS"),
        "S002": Student(student_id="S002", name="Jane Smith", email="jane@example.com", enrolled_degree_id="BS-CS"),
    }
    
    student_courses: Dict[str, List[Course]] = {
        "S001": [
            Course(course_id="MATH101", title="Calculus I", credits=4.0, grade=Grade.A),
            Course(course_id="CS101", title="Intro to Programming", credits=3.0, grade=Grade.A),
            Course(course_id="CS201", title="Data Structures", credits=3.0, grade=Grade.B),
            Course(course_id="PHYS101", title="Physics I", credits=4.0, grade=Grade.A),
            Course(course_id="ENG101", title="English Comp", credits=3.0, grade=Grade.C),
        ],
        "S002": [
            Course(course_id="MATH101", title="Calculus I", credits=4.0, grade=Grade.B),
            Course(course_id="CS101", title="Intro to Programming", credits=3.0, grade=Grade.A),
            Course(course_id="ENG101", title="English Comp", credits=3.0, grade=Grade.A),
        ],
    }
    
    degrees: Dict[str, DegreeRequirement] = {
        "BS-CS": DegreeRequirement(
            degree_id="BS-CS",
            name="Bachelor of Science in Computer Science",
            total_credits_required=120.0,
            required_courses=["MATH101", "CS101", "CS201", "PHYS101"],
            elective_credits_required=30.0
        ),
    }
    
    # Endpoints
    
    @app.get("/students/{student_id}", response_model=Student, summary="Get student profile")
    async def get_student(student_id: str = Path(..., min_length=1)):
        if student_id not in students:
            raise HTTPException(status_code=404, detail="Student not found")
        return students[student_id]
    
    @app.get("/students/{student_id}/courses", response_model=List[Course], summary="Get student's completed courses")
    async def get_student_courses(
        student_id: str = Path(..., min_length=1),
        status: Optional[CourseStatus] = Query(CourseStatus.COMPLETED)
    ):
        if student_id not in student_courses:
            raise HTTPException(status_code=404, detail="No courses found for student")
        return [c for c in student_courses[student_id] if c.status == status]
    
    @app.get("/degrees/{degree_id}", response_model=DegreeRequirement, summary="Get degree requirements")
    async def get_degree(degree_id: str = Path(..., min_length=1)):
        if degree_id not in degrees:
            raise HTTPException(status_code=404, detail="Degree not found")
        return degrees[degree_id]
    
    @app.post("/audits", response_model=AuditResult, summary="Run degree audit for a student")
    async def run_audit(request: AuditRequest):
        if request.student_id not in students:
            raise HTTPException(status_code=404, detail="Student not found")
        if request.degree_id not in degrees:
            raise HTTPException(status_code=404, detail="Degree not found")
    
        student = students[request.student_id]
        degree = degrees[request.degree_id]
        courses = student_courses.get(request.student_id, [])
    
        # Compute audit
        completed_credits = sum(c.credits for c in courses if c.status == CourseStatus.COMPLETED and c.grade is not None and c.grade != Grade.F)
        required_course_ids = set(degree.required_courses)
        fulfilled_required = [c.course_id for c in courses if c.course_id in required_course_ids and c.status == CourseStatus.COMPLETED and c.grade is not None and c.grade != Grade.F]
        missing_required = list(required_course_ids - set(fulfilled_required))
    
        # Simple elective logic: any non-required completed credits count towards electives
        elective_credits_used = sum(c.credits for c in courses if c.status == CourseStatus.COMPLETED and c.grade is not None and c.grade != Grade.F and c.course_id not in required_course_ids)
    
        is_ready = (
            completed_credits >= degree.total_credits_required and
            len(missing_required) == 0 and
            elective_credits_used >= degree.elective_credits_required
        )
    
        notes = []
        if len(missing_required) > 0:
            notes.append(f"Missing required courses: {', '.join(missing_required)}")
        if completed_credits < degree.total_credits_required:
            notes.append(f"Short {degree.total_credits_required - completed_credits:.1f} credits")
    
        return AuditResult(
            student_id=request.student_id,
            degree_id=request.degree_id,
            degree_name=degree.name,
            total_credits_required=degree.total_credits_required,
            completed_credits=completed_credits,
            elective_credits_used=elective_credits_used,
            required_courses=degree.required_courses,
            fulfilled_required_courses=fulfilled_required,
            missing_required_courses=missing_required,
            is_graduation_ready=is_ready,
            notes=notes
        )
    
    @app.get("/health", summary="Health check")
    async def health_check():
        return {"status": "healthy"}
    
    if __name__ == "__main__":
        uvicorn.run(app, host="0.0.0.0", port=8000)
    

    Quick Start & Usage

    1. Install dependencies:

      pip install fastapi uvicorn pydantic
      
    2. Run the server:

      uvicorn main:app --reload --host 0.0.0.0 --port 8000
      
    3. Example Requests (using curl or Swagger UI):

      • Get student: curl http://localhost:8000/students/S001

        {"student_id":"S001","name":"John Doe","email":"john@example.com","enrolled_degree_id":"BS-CS"}
        
      • Get courses: curl http://localhost:8000/students/S001/courses

        [{"course_id":"MATH101","title":"Calculus I","credits":4.0,"grade":"A","status":"completed"}, ...]
        
      • Get degree: curl http://localhost:8000/degrees/BS-CS

      • Run audit:

        curl -X POST http://localhost:8000/audits \
          -H "Content-Type: application/json" \
          -d '{"student_id":"S001","degree_id":"BS-CS"}'
        
        {
          "student_id": "S001",
          "degree_id": "BS-CS",
          "degree_name": "Bachelor of Science in Computer Science",
          "total_credits_required": 120.0,
          "completed_credits": 17.0,
          "elective_credits_used": 3.0,
          "required_courses": ["MATH101", "CS101", "CS201", "PHYS101"],
          "fulfilled_required_courses": ["MATH101", "CS101", "CS201", "PHYS101"],
          "missing_required_courses": [],
          "is_graduation_ready": false,
          "notes": ["Short 103.0 credits"]
        }
        

    Production Extensions

    • Database: Integrate SQLAlchemy + PostgreSQL (e.g., asyncpg). Replace in-memory dicts with CRUD repos.
    • Auth: Add JWT with fastapi-security or OAuth2 for integrations.
    • Advanced Audits: Support complex rules (min GPA, prerequisites) via a rules engine like rule_engine.
    • Pagination/Search: Add for courses/students lists.
    • Webhooks: POST /webhooks/audit-complete for real-time integrations.
    • Rate Limiting/Caching: Use slowapi and Redis.

    This API is ready for degree audit systems (e.g., DegreeWorks, uAchieve) to integrate via simple HTTP calls. Customize data/audit logic as needed! 🚀

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.