Upload 18 files

Student Management System codebase

Dockerfile

@@ -0,0 +1,25 @@
+FROM python:3.11.9-slim
+
+# Copy requirements file
+COPY requirements.txt .
+
+# Update pip
+RUN pip --timeout=3000 install --no-cache-dir --upgrade pip
+
+# Install dependecies
+RUN pip --timeout=3000 install --no-cache-dir -r requirements.txt
+
+# Make api
+RUN mkdir -p /api/
+
+# Set app as the working directory
+WORKDIR /api
+
+# Copy api
+COPY . .
+
+# Expose app port Huggingface 
+EXPOSE 7860
+
+# Start application
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

config.py

@@ -0,0 +1,41 @@
+from pathlib import Path
+
+# ENV when using standalone uvicorn server running FastAPI in api directory
+ENV_PATH = Path("../env/api.env")
+
+ONE_DAY_SEC = 24*60*60
+
+ONE_WEEK_SEC = ONE_DAY_SEC*7
+
+# Cache
+USE_REDIS_CACHE = True  # Change to True to use Redis Cache
+
+# Postgres
+USE_POSTGRES_DB = True  # Change to True to use Posgres DB
+
+
+DESCRIPTION = """
+This API is the backend of the student management system.\n
+
+Manages students, instructors, courses, and enrollments within an educational institution.\n
+
+Provides functionalities to manage students, instructors, and courses, as well as 
+to enroll students in courses and assign grades.\n
+
+- Add, remove, and update students and instructors
+- Add, remove, and update courses
+- Enroll students in courses
+- Assign grades to students for specific courses
+- Retrieve a list of students enrolled in a specific course
+- Retrieve a list of courses a specific student is enrolled in
+
+
+### GitHub 
+[![GitHub Logo](https://github.com/favicon.ico) D0nG4667](https://github.com/D0nG4667/Student-Management-System)
+
+### Explore this api below
+⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️
+
+
+© 2024, Made with 💖 [Gabriel Okundaye](https://www.linkedin.com/in/dr-gabriel-okundaye) 
+"""

main.py

@@ -0,0 +1,340 @@
+import os
+from dotenv import load_dotenv
+
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi_cache import FastAPICache
+from fastapi_cache.backends.inmemory import InMemoryBackend
+# from fastapi_cache.coder import PickleCoder
+from fastapi_cache.decorator import cache
+
+from typing import Union, Optional, Type
+from utils.student import Student
+from utils.instructor import Instructor
+from utils.course import Course
+from utils.enrollment import Enrollment
+
+from utils.logging import logging
+
+from sqlmodel import SQLModel, select
+from sqlmodel.sql.expression import SelectOfScalar
+from sqlmodel.ext.asyncio.session import AsyncSession
+
+from sqlalchemy.ext.asyncio import create_async_engine
+from sqlalchemy import Engine
+
+from typing import Dict
+
+
+from config import (
+    # ONE_DAY_SEC,
+    ONE_WEEK_SEC,
+    ENV_PATH,
+    USE_REDIS_CACHE,
+    USE_POSTGRES_DB,
+    DESCRIPTION,
+)
+
+load_dotenv(ENV_PATH)
+
+sms_resource: Dict[str,
+                   Union[Engine, logging.Logger]] = {}
+
+
+@asynccontextmanager
+async def lifespan(_: FastAPI) -> AsyncIterator[None]:
+    # Cache
+    if USE_REDIS_CACHE:
+        from redis import asyncio as aioredis
+        from fastapi_cache.backends.redis import RedisBackend
+        url = os.getenv("REDIS_URL")
+        username = os.getenv("REDIS_USERNAME")
+        password = os.getenv("REDIS_PASSWORD")
+        redis = aioredis.from_url(url=url, username=username,
+                                  password=password, encoding="utf8", decode_responses=True)
+        FastAPICache.init(RedisBackend(redis), prefix="fastapi-cache")
+    else:
+        # In Memory cache
+        FastAPICache.init(InMemoryBackend())
+
+    # Database
+    if USE_POSTGRES_DB:
+        DATABASE_URL = os.getenv("POSTGRES_URL")
+        connect_args = {
+            "timeout": 60
+        }
+    else:  # sqlite
+        DATABASE_URL = "sqlite+aiosqlite:///sms.db"
+        # Allow a single connection to be accessed from multiple threads.
+        connect_args = {"check_same_thread": False}
+
+    # Define the async engine
+    engine = create_async_engine(
+        DATABASE_URL, echo=True, connect_args=connect_args)
+
+    sms_resource["engine"] = engine
+
+    # Startup actions: create database tables
+    async with engine.begin() as conn:
+        await conn.run_sync(SQLModel.metadata.create_all)
+
+    # Logger
+    logger = logging.getLogger(__name__)
+
+    sms_resource["logger"] = logger
+
+    yield  # Application code runs here
+
+    # Shutdown actions: close connections, etc.
+    await engine.dispose()
+
+
+# FastAPI Object
+app = FastAPI(
+    title='School Management System API',
+    version='1.0.0',
+    description=DESCRIPTION,
+    lifespan=lifespan,
+)
+
+app.mount("/assets", StaticFiles(directory="assets"), name="assets")
+
+
+@app.get('/favicon.ico', include_in_schema=False)
+@cache(expire=ONE_WEEK_SEC, namespace='eta_favicon')  # Cache for 1 week
+async def favicon():
+    file_name = "favicon.ico"
+    file_path = os.path.join(app.root_path, "assets", file_name)
+    return FileResponse(path=file_path, headers={"Content-Disposition": "attachment; filename=" + file_name})
+
+
+# API
+
+OneResult = Union[Student, Instructor, Course, Enrollment]
+OneResultItem = Optional[OneResult]
+
+BulkResult = Dict[str, OneResult]
+BulkResultItem = Optional[BulkResult]
+
+Result = Union[OneResult, BulkResult]
+ResultItem = Union[OneResultItem, BulkResultItem]
+
+
+class EndpointResponse(SQLModel):
+    execution_msg: str
+    execution_code: int
+    result: ResultItem
+
+
+class ErrorResponse(SQLModel):
+    execution_msg: str
+    execution_code: int
+    error: Optional[str]
+
+
+# Endpoints
+
+# Status endpoint: check if api is online
+@app.get('/', tags=['Home'])
+async def status_check():
+    return {"Status": "API is online..."}
+
+
+async def endpoint_output(endpoint_result: Result, code: int = 0, error: str = None) -> Union[ErrorResponse, EndpointResponse]:
+    msg = 'Execution failed'
+    output = ErrorResponse(**{'execution_msg': msg,
+                              'execution_code': code, 'error': error})
+
+    try:
+        if code != 0:
+            msg = 'Execution was successful'
+            output = EndpointResponse(
+                **{'execution_msg': msg,
+                   'execution_code': code, 'result': endpoint_result}
+            )
+
+    except Exception as e:
+        code = 0
+        msg = 'Execution failed'
+        errors = f"Omg, an error occurred. endpoint_output Error: {e} & endpoint_result Error: {error} & endpoint_result: {endpoint_result}"
+        output = ErrorResponse(**{'execution_msg': msg,
+                                  'execution_code': code, 'error': errors})
+
+        sms_resource["logger"].error(error)
+
+    finally:
+        return output
+
+
+# Caching Post requests is challenging
+async def sms_posts(instance: Result, idx: str = None, action: str = "add") -> Union[ErrorResponse, EndpointResponse]:
+    async with AsyncSession(sms_resource["engine"]) as session:
+        code = 0
+        error = None
+        existing = await session.get(instance.__class__, idx)
+
+        # For add action, do db operation if instance is not existing. Other actions, do db operation if instance exists in db
+        checker = existing is None if action == "add" else existing is not None
+
+        try:
+            if checker:
+                if action == "delete":
+                    session.delete(instance)
+                else:  # add or update use add
+                    session.add(instance)
+                await session.commit()
+                await session.refresh(instance)
+                code = 1
+        except Exception as e:
+            error = e
+
+        finally:
+            return await endpoint_output(instance, code, error)
+
+
+# @cache(expire=ONE_DAY_SEC, namespace='sms_gets')  # Cache for 1 day
+async def sms_gets(sms_class: Type[Result], action: str = "first", idx: str = None, stmt: SelectOfScalar[Type[Result]] = None) -> Union[ErrorResponse, EndpointResponse]:
+    async with AsyncSession(sms_resource["engine"]) as session:
+        result = None
+        error = None
+        code = 1
+        try:
+            if action == "all":
+                statement = select(sms_class) if stmt is None else stmt
+                instance_list = (await session.exec(statement)).all()
+                if instance_list:
+                    result = {
+                        str(instance.id): instance for instance in instance_list}
+            elif action == "first":
+                statement = select(sms_class).where(
+                    sms_class.id == idx) if stmt is None else stmt
+                result = (await session.exec(statement)).first()
+
+        except Exception as e:
+            code = 0
+            error = e
+        finally:
+            return await endpoint_output(result, code, error)
+
+
+# Student Routes
+
+@app.post('/api/v1/sms/add_student', tags=['Student'])
+async def add_student(student: Student) -> Union[ErrorResponse, EndpointResponse]:
+    return await sms_posts(student, student.id, action="add")
+
+
+@app.put('/api/v1/sms/update_student', tags=['Student'])
+async def update_student(student: Student) -> Union[ErrorResponse, EndpointResponse]:
+    return await sms_posts(student, student.id, action="update")
+
+
+@app.delete('/api/v1/sms/delete_student', tags=['Student'])
+async def delete_student(student: Student) -> Union[ErrorResponse, EndpointResponse]:
+    return await sms_posts(student, student.id, action="delete")
+
+
+@app.get("/api/v1/sms/students/{id}", tags=['Student'])
+async def find_student(id: str) -> Union[ErrorResponse, EndpointResponse]:
+    return await sms_gets(Student, "first", id)
+
+
+@app.get("/api/v1/sms/students", tags=['Student'])
+async def all_students() -> Union[ErrorResponse, EndpointResponse]:
+    return await sms_gets(Student, "all")
+
+
+# Instructor Routes
+
+@app.post('/api/v1/sms/add_instructor', tags=['Instructor'])
+async def add_instructor(instructor: Instructor) -> Union[ErrorResponse, EndpointResponse]:
+    return await sms_posts(instructor, instructor.id, action="add")
+
+
+@app.put('/api/v1/sms/update_instructor', tags=['Instructor'])
+async def update_instructor(instructor: Instructor) -> Union[ErrorResponse, EndpointResponse]:
+    return await sms_posts(instructor, instructor.id, action="update")
+
+
+@app.delete('/api/v1/sms/delete_instructor', tags=['Instructor'])
+async def delete_student(instructor: Instructor) -> Union[ErrorResponse, EndpointResponse]:
+    return await sms_posts(instructor, instructor.id, action="delete")
+
+
+@app.get("/api/v1/sms/instructors/{id}", tags=['Instructor'])
+async def find_instructor(id: str) -> Union[ErrorResponse, EndpointResponse]:
+    return await sms_gets(Instructor, "first", id)
+
+
+@app.get("/api/v1/sms/instructors", tags=['Instructor'])
+async def all_instructors() -> Union[ErrorResponse, EndpointResponse]:
+    return await sms_gets(Instructor, "all")
+
+
+# Course Routes
+
+@app.post('/api/v1/sms/add_course', tags=['Course'])
+async def add_course(course: Course) -> Union[ErrorResponse, EndpointResponse]:
+    return await sms_posts(course, course.id, action="add")
+
+
+@app.put('/api/v1/sms/update_course', tags=['Course'])
+async def update_course(course: Course) -> Union[ErrorResponse, EndpointResponse]:
+    return await sms_posts(course, course.id, action="update")
+
+
+@app.delete('/api/v1/sms/delete_course', tags=['Course'])
+async def delete_student(course: Course) -> Union[ErrorResponse, EndpointResponse]:
+    return await sms_posts(course, course.id, action="delete")
+
+
+@app.get("/api/v1/sms/courses/{id}", tags=['Course'])
+async def find_course(id: str) -> Union[ErrorResponse, EndpointResponse]:
+    return await sms_gets(Course, "first", id)
+
+
+@app.get("/api/v1/sms/courses", tags=['Course'])
+async def all_courses() -> Union[ErrorResponse, EndpointResponse]:
+    return await sms_gets(Course, "all")
+
+
+# Enroll Routes
+
+@app.post('/api/v1/sms/enroll_student', tags=['Enroll'])
+async def enroll_student(enrollment: Enrollment) -> Union[ErrorResponse, EndpointResponse]:
+    return await sms_posts(enrollment, enrollment.id, action="add")
+
+
+@app.put('/api/v1/sms/update_enrolled_student', tags=['Enroll'])
+async def update_enrolled_student(enrollment: Enrollment) -> Union[ErrorResponse, EndpointResponse]:
+    return await sms_posts(enrollment, enrollment.id, action="update")
+
+
+@app.delete('/api/v1/sms/delete_enrolled_student', tags=['Enroll'])
+async def delete_enrolled_student(enrollment: Enrollment) -> Union[ErrorResponse, EndpointResponse]:
+    return await sms_posts(enrollment, enrollment.id, action="delete")
+
+
+@app.get('/api/v1/sms/enrollments/{id}', tags=['Enroll'])
+async def find_enrollment_by_id(id: str) -> Union[ErrorResponse, EndpointResponse]:
+    return await sms_gets(Enrollment, "first", id)
+
+
+@app.get('/api/v1/sms/enrollments/{student_id}', tags=['Enroll'])
+async def find_enrollment_by_student_id(student_id: str) -> Union[ErrorResponse, EndpointResponse]:
+    stmt = select(Enrollment).where(Enrollment.student_id == student_id)
+    return await sms_gets(Enrollment, action="all", stmt=stmt)
+
+
+@app.get('/api/v1/sms/enrollments', tags=['Enroll'])
+async def all_enrolled_students() -> Union[ErrorResponse, EndpointResponse]:
+    return await sms_gets(Enrollment, "all")
+
+
+@app.put('/api/v1/sms/grade_student', tags=['Grade'])
+async def assign_grade(enrollment: Enrollment) -> Union[ErrorResponse, EndpointResponse]:
+    return await sms_posts(enrollment, enrollment.id, action="update")

requirements.txt

@@ -0,0 +1,119 @@
+aioredis==1.3.1
+aiosqlite==0.20.0
+annotated-types==0.7.0
+anyio==4.4.0
+argon2-cffi==23.1.0
+argon2-cffi-bindings==21.2.0
+arrow==1.3.0
+asn1crypto==1.5.1
+asttokens==2.4.1
+async-lru==2.0.4
+async-timeout==4.0.3
+asyncpg==0.29.0
+attrs==23.2.0
+Babel==2.14.0
+beautifulsoup4==4.12.3
+bleach==6.1.0
+Brotli==1.1.0
+cached-property==1.5.2
+certifi==2024.7.4
+cffi==1.16.0
+charset-normalizer==3.3.2
+click==8.1.7
+colorama==0.4.6
+comm==0.2.2
+debugpy==1.8.2
+decorator==5.1.1
+defusedxml==0.7.1
+entrypoints==0.4
+exceptiongroup==1.2.2
+executing==2.0.1
+fastapi==0.112.1
+fastapi-cache2==0.2.2
+fastjsonschema==2.20.0
+fqdn==1.5.1
+greenlet==3.0.3
+h11==0.14.0
+h2==4.1.0
+hiredis==3.0.0
+hpack==4.0.0
+httpcore==1.0.5
+httpx==0.27.0
+hyperframe==6.0.1
+idna==3.7
+importlib_metadata==8.2.0
+importlib_resources==6.4.0
+isoduration==20.11.0
+jedi==0.19.1
+Jinja2==3.1.4
+json5==0.9.25
+jsonpointer==3.0.0
+jsonschema==4.23.0
+jsonschema-specifications==2023.12.1
+MarkupSafe==2.1.5
+matplotlib-inline==0.1.7
+mistune==3.0.2
+nest_asyncio==1.6.0
+overrides==7.7.0
+packaging==24.1
+pandocfilters==1.5.0
+parso==0.8.4
+pendulum==3.0.0
+pg8000==1.31.2
+pickleshare==0.7.5
+pkgutil_resolve_name==1.3.10
+platformdirs==4.2.2
+prometheus_client==0.20.0
+prompt_toolkit==3.0.47
+psutil==6.0.0
+# psycopg2==2.9.9
+psycopg2-binary==2.9.9
+pure_eval==0.2.3
+pycparser==2.22
+pydantic==2.8.2
+pydantic_core==2.20.1
+Pygments==2.18.0
+PySocks==1.7.1
+python-dateutil==2.9.0
+python-dotenv==1.0.1
+python-json-logger==2.0.7
+pytz==2024.1
+PyYAML==6.0.1
+pyzmq==24.0.1
+redis==5.0.8
+referencing==0.35.1
+requests==2.32.3
+rfc3339-validator==0.1.4
+rfc3986-validator==0.1.1
+rpds-py==0.19.1
+scramp==1.4.5
+Send2Trash==1.8.3
+setuptools==69.5.1
+six==1.16.0
+sniffio==1.3.1
+soupsieve==2.5
+SQLAlchemy==2.0.31
+sqlmodel==0.0.21
+stack-data==0.6.2
+starlette==0.38.2
+tenacity==9.0.0
+terminado==0.18.1
+time-machine==2.15.0
+tinycss2==1.3.0
+tomli==2.0.1
+tornado==6.4.1
+traitlets==5.14.3
+types-python-dateutil==2.9.0.20240316
+typing_extensions==4.12.2
+typing-utils==0.1.0
+tzdata==2024.1
+uri-template==1.3.0
+urllib3==2.2.2
+uvicorn==0.30.6
+wcwidth==0.2.13
+webcolors==24.6.0
+webencodings==0.5.1
+websocket-client==1.8.0
+wheel==0.43.0
+zipp==3.19.2
+zstandard==0.22.0

utils/course.py

@@ -0,0 +1,39 @@
+from typing import List
+from sqlmodel import SQLModel, Field, Relationship
+
+from utils.enums.course_name_id import CourseNameId
+from .instructor import Instructor
+from .enrollment import Enrollment
+
+
+class Course(SQLModel, table=True):
+    """
+    Represents a course, including its name, unique identifier, enrolled students, and instructors.
+
+    Attributes:
+        id (str): A unique identifier for the course.
+        course_name (str): The name of the course.        
+        enrolled_students (Dict[str, Enrollment]): A dictionary mapping student IDs to `Enrollment` instances for students enrolled in the course. 
+        instructors (Dict[str, Instructor]): A dictionary mapping instructor IDs to `Instructor` instances for those teaching the course, or None if no instructors are assigned.
+
+    Notes:
+        Attributes defaults to an empty dictionary using default_factory. This ensures that each instance of the class gets a new dictionary instead of sharing a single instance across all instances of the model.
+    """
+
+    id: str = Field(
+        default=CourseNameId.INTRO_TO_PROGRAMMING.course_id, primary_key=True)
+    course_name: str = Field(
+        default=CourseNameId.INTRO_TO_PROGRAMMING.course_name)
+
+    enrollments: List[Enrollment] = Relationship(
+        back_populates="course", cascade_delete=True)
+    instructors: List[Instructor] = Relationship(back_populates="course")
+
+    def __str__(self) -> str:
+        """
+        Returns a string representation of the course.
+
+        Returns:
+            str: A string describing the course, including the course name, course ID, and the number of enrolled students.
+        """
+        return f"Course(course_name: {self.course_name}, id: {self.id}, enrolled_students: {self.enrollments}, total_students_enrolled: {len(self.enrollments)}, instructors: {self.instructors}, total_instructors: {len(self.instructors)})"

utils/enrollment.py

@@ -0,0 +1,44 @@
+from typing import Optional
+from utils.enums.grade import Grade
+
+from .student import Student
+
+from sqlmodel import SQLModel, Field, Relationship
+
+
+class Enrollment(SQLModel, table=True):
+    """
+    Represents an Enrollment, including the student, the course they are enrolled in, and the assigned grade.
+
+    Attributes:
+        id: (int): The enrollment ID
+        student_id (str): The ID of the student who is enrolled in the course.
+        course_id (str): The ID of the course in which the student is enrolled.
+        grade (Grade): The grade assigned to the student for the course. Default if NO_GRADE with enum value of None if no grade has been assigned yet.
+    """
+
+    id: int = Field(primary_key=True)
+    student_id: str = Field(foreign_key="student.id")
+    course_id: str = Field(foreign_key="course.id")
+    grade: Grade = Field(sa_column=Field(sa_type=Grade))
+
+    course: "Course" = Relationship(
+        back_populates="enrollments")
+
+    def assign_grade(self, grade: Grade) -> None:
+        """
+        Assigns a grade to the student for the course.
+
+        Args:
+            grade (Grade): The grade to assign to the student.
+        """
+        self.grade = grade
+
+    def __str__(self) -> str:
+        """
+        Returns a string representation of the Enrollment.
+
+        Returns:
+            str: A description of the enrollment including the student id_number, course_id, and grade.
+        """
+        return f"Enrollment(student id: {self.student_id}, course: {self.course_id}, grade: {self.grade.value})"

utils/enums/__init__.py

@@ -0,0 +1,5 @@
+from .course_name_id import CourseNameId
+from .department import Department
+from .grade import Grade
+from .major import Major
+

utils/enums/course_name_id.py

@@ -0,0 +1,44 @@
+from enum import Enum
+
+
+class CourseNameId(Enum):
+    """
+    Enum representing various courses with their corresponding IDs.
+    """
+    INTRO_TO_PROGRAMMING = ("Introduction to Programming", "CS101")
+    DATA_STRUCTURES = ("Data Structures", "CS102")
+    ALGORITHMS = ("Algorithms", "CS201")
+    OPERATING_SYSTEMS = ("Operating Systems", "CS202")
+    DATABASE_SYSTEMS = ("Database Systems", "CS301")
+    LINEAR_ALGEBRA = ("Linear Algebra", "MATH101")
+    CALCULUS = ("Calculus", "MATH102")
+    ORGANIC_CHEMISTRY = ("Organic Chemistry", "CHEM101")
+    PHYSICS_I = ("Physics I", "PHYS101")
+    PHYSICS_II = ("Physics II", "PHYS102")
+    MICROECONOMICS = ("Microeconomics", "ECON101")
+    MACROECONOMICS = ("Macroeconomics", "ECON102")
+    INTRO_TO_PSYCHOLOGY = ("Introduction to Psychology", "PSYCH101")
+    SOCIOLOGY_THEORY = ("Sociological Theory", "SOC101")
+    AMERICAN_LITERATURE = ("American Literature", "ENGL101")
+    WORLD_HISTORY = ("World History", "HIST101")
+    CONSTITUTIONAL_LAW = ("Constitutional Law", "LAW101")
+    BIOCHEMISTRY = ("Biochemistry", "BIOCHEM101")
+    ENGINEERING_MECHANICS = ("Engineering Mechanics", "MECH101")
+    ART_HISTORY = ("Art History", "ART101")
+    MUSIC_THEORY = ("Music Theory", "MUSIC101")
+    ANATOMY = ("Anatomy", "BIO101")
+
+    def __init__(self, course_name: str, course_id: str) -> None:
+        self._course_name = course_name
+        self._course_id = course_id
+
+    @property
+    def course_name(self) -> str:
+        return self._course_name
+
+    @property
+    def course_id(self) -> str:
+        return self._course_id
+
+    def __str__(self) -> str:
+        return f"CourseNameId(course_name: {self._course_name}, course_id: {self._course_id})"

utils/enums/department.py

@@ -0,0 +1,47 @@
+from enum import Enum
+
+
+class Department(Enum):
+    """
+    Enum representing valid departments.
+    """
+    MATHEMATICS = "Mathematics"
+    PHYSICS = "Physics"
+    CHEMISTRY = "Chemistry"
+    COMPUTER_SCIENCE = "Computer Science"
+    BIOLOGICAL_SCIENCES = "Biological Sciences"
+    ENGLISH = "English Language and Literature"
+    HISTORY = "History"
+    ECONOMICS = "Economics"
+    BUSINESS_ADMINISTRATION = "Business Administration"
+    PSYCHOLOGY = "Psychology"
+    SOCIOLOGY = "Sociology"
+    ENGINEERING = "Engineering"
+    ART_AND_DESIGN = "Art and Design"
+    MUSIC = "Music"
+    THEATER_ARTS = "Theater Arts"
+    PHILOSOPHY = "Philosophy"
+    POLITICAL_SCIENCE = "Political Science"
+    EDUCATION = "Education"
+    ENVIRONMENTAL_SCIENCE = "Environmental Science"
+    NURSING = "Nursing"
+    LAW = "Law"
+    MEDICINE = "Medicine"
+    DENTISTRY = "Dentistry"
+    ARCHITECTURE = "Architecture"
+    PHARMACY = "Pharmacy"
+    ASTRONOMY = "Astronomy"
+    LINGUISTICS = "Linguistics"
+    ANTHROPOLOGY = "Anthropology"
+    COMPUTER_ENGINEERING = "Computer Engineering"
+    ELECTRICAL_ENGINEERING = "Electrical Engineering"
+    MECHANICAL_ENGINEERING = "Mechanical Engineering"
+    CIVIL_ENGINEERING = "Civil Engineering"
+    CHEMICAL_ENGINEERING = "Chemical Engineering"
+    MATERIALS_SCIENCE = "Materials Science"
+    STATISTICS = "Statistics"
+    PUBLIC_HEALTH = "Public Health"
+    SOCIAL_WORK = "Social Work"
+    INTERNATIONAL_RELATIONS = "International Relations"
+    MEDIA_STUDIES = "Media Studies"
+    RELIGIOUS_STUDIES = "Religious Studies"

utils/enums/grade.py

@@ -0,0 +1,23 @@
+from enum import Enum
+
+
+class Grade(str, Enum):
+    """
+    Enum representing possible letter grades.
+    """
+    A_PLUS = "A+"
+    A = "A"
+    A_MINUS = "A-"
+    B_PLUS = "B+"
+    B = "B"
+    B_MINUS = "B-"
+    C_PLUS = "C+"
+    C = "C"
+    C_MINUS = "C-"
+    D_PLUS = "D+"
+    D = "D"
+    D_MINUS = "D-"
+    F = "F"
+    PASS = "Pass"
+    FAIL = "Fail"
+    NO_GRADE = None

utils/enums/major.py

@@ -0,0 +1,32 @@
+from enum import Enum
+
+
+class Major(str, Enum):
+    """
+    Enum representing various academic majors.
+    Add others.
+    """
+    COMPUTER_SCIENCE = "Computer Science"
+    ELECTRICAL_ENGINEERING = "Electrical Engineering"
+    MECHANICAL_ENGINEERING = "Mechanical Engineering"
+    CIVIL_ENGINEERING = "Civil Engineering"
+    CHEMICAL_ENGINEERING = "Chemical Engineering"
+    BIOLOGY = "Biology"
+    PHYSICS = "Physics"
+    CHEMISTRY = "Chemistry"
+    MATHEMATICS = "Mathematics"
+    BUSINESS_ADMINISTRATION = "Business Administration"
+    ECONOMICS = "Economics"
+    PSYCHOLOGY = "Psychology"
+    SOCIOLOGY = "Sociology"
+    ENGLISH = "English"
+    HISTORY = "History"
+    POLITICAL_SCIENCE = "Political Science"
+    PHILOSOPHY = "Philosophy"
+    ART_AND_DESIGN = "Art and Design"
+    MUSIC = "Music"
+    NURSING = "Nursing"
+    LAW = "Law"
+    MEDICINE = "Medicine"
+    ARCHITECTURE = "Architecture"
+    ENVIRONMENTAL_SCIENCE = "Environmental Science"

utils/instructor.py

@@ -0,0 +1,41 @@
+from typing_extensions import Self, Optional
+from pydantic import model_validator
+from sqlmodel import Field, Relationship
+
+
+from .person import Person
+from utils.enums.department import Department
+
+
+class Instructor(Person, table=True):
+    """
+    Represents an Instructor, inheriting from Person, with an additional department field.
+
+    Attributes:
+        department (Department): The  instructor's department.
+
+    Methods:
+        set_id() -> Self: An SQLmodel validator that automatically sets the instructor's ID with a "INS" prefix through handle_id method in the Person class.
+    """
+
+    department: Department = Field(sa_column=Field(sa_type=Department))
+
+    course_id: Optional[str] = Field(
+        default=None, foreign_key="course.id")
+    course: Optional["Course"] = Relationship(
+        back_populates="instructors")
+
+    @model_validator(mode='after')
+    def set_id(self) -> Self:
+        self.handle_id(prefix="INS")
+        return self
+
+    def __str__(self) -> str:
+        """
+        Returns a string representation of the instructor.
+
+        Returns:
+            str: A description of the instructor including their name, ID number, and department.
+        """
+
+        return f"Instructor(name: {self.name}, id: {self.id}, department: {self.department.value})"

utils/logging.py

@@ -0,0 +1,4 @@
+import logging
+
+logging.basicConfig(level=logging.ERROR,
+                    format='%(asctime)s - %(levelname)s - %(message)s')

utils/person.py

@@ -0,0 +1,76 @@
+import uuid
+from typing import Optional
+from typing_extensions import Self
+
+from pydantic import model_validator
+from sqlmodel import SQLModel, Field
+
+
+class Person(SQLModel):
+    """
+    A class representing a person with a first name, last name, and optional ID number.
+
+    Attributes:
+        id (str, optional): An optional identifier for the person, generated if not provided.
+        first_name (str): The first name of the person.
+        last_name (str): The last name of the person.
+        name (str, optional): The full name of the person, automatically generated from first and last name.
+    """
+    id: Optional[str] = Field(default=None, primary_key=True)
+    first_name: str
+    last_name: str
+    name: Optional[str] = Field(default=None)
+
+    @model_validator(mode='after')
+    def set_name(self) -> Self:
+        """
+        Sets the full name of the person by combining the first and last name.
+
+        Returns:
+            Self: The instance with the name attribute set.
+        """
+
+        self.name = f"{self.first_name} {self.last_name}"
+
+        return self
+
+    @model_validator(mode='after')
+    def set_id(self) -> Self:
+        """
+        Sets a unique ID for the person if one is not provided.
+
+        Returns:
+            Self: The instance with the id attribute set.
+        """
+
+        self.handle_id()
+        return self
+
+    def handle_id(self, prefix: str = "PER") -> None:
+        """
+        Generates or returns a unique identifier with a given prefix.
+
+        Args:
+            prefix (str): The prefix to be added to the ID.
+            id (Optional[str]): An optional ID. If provided, it is returned as-is.
+
+        Returns:
+            str: A unique identifier with the given prefix. If no ID is provided, a new ID is generated using UUID.
+        """
+
+        # Use id if give else generate id
+        if self.id is None or self.id == "":
+            # Generate a random UUID and take only the first 8 characters
+            short_uuid = str(uuid.uuid4())[:8]
+
+            # Add a custom prefix
+            self.id = f"{prefix}-{short_uuid}"
+
+    def __str__(self) -> str:
+        """
+        Returns a string representation of the person.
+
+        Returns:
+            str: A description of the person including their name and ID number.
+        """
+        return f"Person(name: {self.name}, id: {self.id})"

utils/student.py

@@ -0,0 +1,37 @@
+from typing import Optional
+from pydantic import model_validator
+from sqlmodel import Field
+from typing_extensions import Self
+
+from .person import Person
+from utils.enums.major import Major
+
+
+class Student(Person, table=True):
+    """
+    Represents a Student, inheriting from Person, with an additional major field.
+
+    Attributes:
+        major (Major): The major that the student is pursuing.
+
+    Methods:
+        set_id() -> Self: An SQLModel model validator that automatically sets the student's ID with a "STU" prefix through handle_id method in the Person class.
+    """
+
+    major: Major = Field(sa_column=Field(sa_type=Major))
+
+    @model_validator(mode='after')
+    def set_id(self) -> Self:
+        self.handle_id(prefix="STU")
+
+        return self
+
+    def __str__(self) -> str:
+        """
+        Returns a string representation of the student.
+
+        Returns:
+            str: A description of the student including their name, ID number, and major.
+        """
+
+        return f"Student(name: {self.name}, id: {self.id}, major: {self.major.value})"