Implement comprehensive school portal API with FastAPI

- Complete authentication system with JWT and role-based access control - User management for Admin, Teacher, Student, and Parent roles - Student management with CRUD operations - Class management and assignment system - Subject and grade tracking functionality - Daily attendance marking and viewing - Notification system for announcements - SQLite database with Alembic migrations - Comprehensive API documentation with Swagger/ReDoc - Proper project structure with services, models, and schemas - Environment variable configuration - CORS support and security features 🤖 Generated with BackendIM Co-Authored-By: BackendIM <noreply@anthropic.com>
2025-06-25 13:31:56 +00:00 · 2025-06-25 13:31:56 +00:00 · 5a02fb8b1f
commit 5a02fb8b1f
parent ab56cbf293
49 changed files with 1780 additions and 2 deletions
--- a/README.md
+++ b/README.md
@ -1,3 +1,152 @@
-# FastAPI Application
+# School Portal API
-This is a FastAPI application bootstrapped by BackendIM, the AI-powered backend generation platform.
+A comprehensive school management system built with Python FastAPI, supporting multiple user roles and complete student lifecycle management.
 ## Features
 ### User Roles
 - **Admin**: Full system access, user management, class management
 - **Teacher**: Student management, grade tracking, attendance marking, notifications
 - **Student**: View grades, attendance, and notifications
 - **Parent**: View child's grades, attendance, and notifications
 ### Core Functionality
 - **Authentication**: JWT-based login and registration for all user roles
 - **Student Management**: Create, update, and delete student profiles
 - **Class Management**: Assign students to classes and teachers to classes
 - **Subject & Grade Tracking**: Teachers record grades per subject, students/parents view them
 - **Attendance**: Daily attendance marking and viewing
 - **Notifications**: Announcements and messages to students and parents
 ## Project Structure
 ```
 schoolportalapi/
 ├── app/
 │   ├── api/
 │   │   └── v1/
 │   │       ├── endpoints/
 │   │       │   ├── auth.py          # Authentication endpoints
 │   │       │   ├── users.py         # User management
 │   │       │   ├── classes.py       # Class management
 │   │       │   ├── subjects.py      # Subject management
 │   │       │   ├── grades.py        # Grade tracking
 │   │       │   ├── attendance.py    # Attendance management
 │   │       │   └── notifications.py # Notification system
 │   │       └── api.py              # API router
 │   ├── core/
 │   │   ├── config.py               # Configuration settings
 │   │   └── security.py             # JWT and password utilities
 │   ├── db/
 │   │   ├── base.py                 # SQLAlchemy base
 │   │   └── session.py              # Database session
 │   ├── models/                     # SQLAlchemy models
 │   │   ├── user.py
 │   │   ├── class_model.py
 │   │   ├── subject.py
 │   │   ├── grade.py
 │   │   ├── attendance.py
 │   │   └── notification.py
 │   ├── schemas/                    # Pydantic schemas
 │   │   ├── user.py
 │   │   ├── class_schema.py
 │   │   ├── subject.py
 │   │   ├── grade.py
 │   │   ├── attendance.py
 │   │   ├── notification.py
 │   │   └── token.py
 │   └── services/                   # Business logic layer
 │       ├── base.py
 │       ├── user.py
 │       ├── class_service.py
 │       ├── subject.py
 │       ├── grade.py
 │       ├── attendance.py
 │       └── notification.py
 ├── alembic/                        # Database migrations
 │   ├── versions/
 │   └── env.py
 ├── main.py                         # FastAPI application entry point
 ├── requirements.txt                # Python dependencies
 └── alembic.ini                     # Alembic configuration
 ```
 ## Setup Instructions
 ### Prerequisites
 - Python 3.8+
 - pip
 ### Installation
 1. **Clone the repository**
   ```bash
   git clone <repository-url>
   cd schoolportalapi
   ```
 2. **Create virtual environment**
   ```bash
   python -m venv venv
   source venv/bin/activate  # On Windows: venv\Scripts\activate
   ```
 3. **Install dependencies**
   ```bash
   pip install -r requirements.txt
   ```
 4. **Set environment variables**
   Create a `.env` file or set the following environment variables:
   ```bash
   # Required Environment Variables
   SECRET_KEY=your-secret-key-change-in-production
   DATABASE_URL=sqlite:////app/storage/db/db.sqlite
   FIRST_SUPERUSER_EMAIL=admin@schoolportal.com
   FIRST_SUPERUSER_PASSWORD=admin123
   ```
 5. **Create storage directory**
   ```bash
   mkdir -p /app/storage/db
   ```
 6. **Run database migrations**
   ```bash
   alembic upgrade head
   ```
 7. **Start the application**
   ```bash
   uvicorn main:app --reload --host 0.0.0.0 --port 8000
   ```
 ## API Documentation
 Once the application is running, access the interactive API documentation:
 - **Swagger UI**: http://localhost:8000/docs
 - **ReDoc**: http://localhost:8000/redoc
 - **OpenAPI JSON**: http://localhost:8000/openapi.json
 ## Environment Variables
 | Variable | Description | Default |
 |----------|-------------|---------|
 | `SECRET_KEY` | JWT secret key | `your-secret-key-change-in-production` |
 | `DATABASE_URL` | Database connection URL | `sqlite:////app/storage/db/db.sqlite` |
 | `FIRST_SUPERUSER_EMAIL` | Initial admin email | `admin@schoolportal.com` |
 | `FIRST_SUPERUSER_PASSWORD` | Initial admin password | `admin123` |
 ## Security Features
 - JWT-based authentication
 - Password hashing using bcrypt
 - Role-based access control
 - CORS configuration for cross-origin requests
 - Input validation using Pydantic schemas
 ## Health Check
 The application provides a health check endpoint:
 - `GET /health` - Returns application health status
--- a/alembic.ini
+++ b/alembic.ini
@ -0,0 +1,41 @@
 [alembic]
 script_location = alembic
 prepend_sys_path = .
 version_path_separator = os
 sqlalchemy.url = sqlite:////app/storage/db/db.sqlite
 [post_write_hooks]
 [loggers]
 keys = root,sqlalchemy,alembic
 [handlers]
 keys = console
 [formatters]
 keys = generic
 [logger_root]
 level = WARN
 handlers = console
 qualname =
 [logger_sqlalchemy]
 level = WARN
 handlers =
 qualname = sqlalchemy.engine
 [logger_alembic]
 level = INFO
 handlers =
 qualname = alembic
 [handler_console]
 class = StreamHandler
 args = (sys.stderr,)
 level = NOTSET
 formatter = generic
 [formatter_generic]
 format = %(levelname)-5.5s [%(name)s] %(message)s
 datefmt = %H:%M:%S
--- a/alembic/env.py
+++ b/alembic/env.py
@ -0,0 +1,49 @@
 from logging.config import fileConfig
 from sqlalchemy import engine_from_config
 from sqlalchemy import pool
 from alembic import context
 import sys
 from pathlib import Path
 sys.path.append(str(Path(__file__).resolve().parent.parent))
 from app.db.base import Base
 config = context.config
 if config.config_file_name is not None:
    fileConfig(config.config_file_name)
 target_metadata = Base.metadata
 def run_migrations_offline() -> None:
    url = config.get_main_option("sqlalchemy.url")
    context.configure(
        url=url,
        target_metadata=target_metadata,
        literal_binds=True,
        dialect_opts={"paramstyle": "named"},
    )
    with context.begin_transaction():
        context.run_migrations()
 def run_migrations_online() -> None:
    connectable = engine_from_config(
        config.get_section(config.config_ini_section),
        prefix="sqlalchemy.",
        poolclass=pool.NullPool,
    )
    with connectable.connect() as connection:
        context.configure(
            connection=connection, target_metadata=target_metadata
        )
        with context.begin_transaction():
            context.run_migrations()
 if context.is_offline_mode():
    run_migrations_offline()
 else:
    run_migrations_online()
--- a/alembic/script.py.mako
+++ b/alembic/script.py.mako
@ -0,0 +1,23 @@
 """${message}
 Revision ID: ${up_revision}
 Revises: ${down_revision | comma,n}
 Create Date: ${create_date}
 """
 from alembic import op
 import sqlalchemy as sa
 ${imports if imports else ""}
 revision = '${up_revision}'
 down_revision = ${repr(down_revision)}
 branch_labels = ${repr(branch_labels)}
 depends_on = ${repr(depends_on)}
 def upgrade() -> None:
    ${upgrades if upgrades else "pass"}
 def downgrade() -> None:
    ${downgrades if downgrades else "pass"}
--- a/alembic/versions/001_initial_migration.py
+++ b/alembic/versions/001_initial_migration.py
@ -0,0 +1,147 @@
 """Initial migration
 Revision ID: 001
 Revises: 
 Create Date: 2024-01-01 00:00:00.000000
 """
 from alembic import op
 import sqlalchemy as sa
 revision = '001'
 down_revision = None
 branch_labels = None
 depends_on = None
 def upgrade() -> None:
    op.create_table('classes',
        sa.Column('id', sa.Integer(), nullable=False),
        sa.Column('name', sa.String(), nullable=False),
        sa.Column('grade_level', sa.String(), nullable=False),
        sa.Column('academic_year', sa.String(), nullable=False),
        sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('(CURRENT_TIMESTAMP)'), nullable=True),
        sa.Column('updated_at', sa.DateTime(timezone=True), nullable=True),
        sa.PrimaryKeyConstraint('id')
    )
    op.create_index(op.f('ix_classes_id'), 'classes', ['id'], unique=False)
    op.create_table('users',
        sa.Column('id', sa.Integer(), nullable=False),
        sa.Column('email', sa.String(), nullable=False),
        sa.Column('hashed_password', sa.String(), nullable=False),
        sa.Column('first_name', sa.String(), nullable=False),
        sa.Column('last_name', sa.String(), nullable=False),
        sa.Column('role', sa.Enum('admin', 'teacher', 'student', 'parent', name='userrole'), nullable=False),
        sa.Column('is_active', sa.Boolean(), nullable=True),
        sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('(CURRENT_TIMESTAMP)'), nullable=True),
        sa.Column('updated_at', sa.DateTime(timezone=True), nullable=True),
        sa.Column('parent_id', sa.Integer(), nullable=True),
        sa.Column('class_id', sa.Integer(), nullable=True),
        sa.ForeignKeyConstraint(['class_id'], ['classes.id'], ),
        sa.ForeignKeyConstraint(['parent_id'], ['users.id'], ),
        sa.PrimaryKeyConstraint('id')
    )
    op.create_index(op.f('ix_users_email'), 'users', ['email'], unique=True)
    op.create_index(op.f('ix_users_id'), 'users', ['id'], unique=False)
    op.create_table('subjects',
        sa.Column('id', sa.Integer(), nullable=False),
        sa.Column('name', sa.String(), nullable=False),
        sa.Column('code', sa.String(), nullable=False),
        sa.Column('description', sa.String(), nullable=True),
        sa.Column('class_id', sa.Integer(), nullable=False),
        sa.Column('teacher_id', sa.Integer(), nullable=False),
        sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('(CURRENT_TIMESTAMP)'), nullable=True),
        sa.Column('updated_at', sa.DateTime(timezone=True), nullable=True),
        sa.ForeignKeyConstraint(['class_id'], ['classes.id'], ),
        sa.ForeignKeyConstraint(['teacher_id'], ['users.id'], ),
        sa.PrimaryKeyConstraint('id'),
        sa.UniqueConstraint('code')
    )
    op.create_index(op.f('ix_subjects_id'), 'subjects', ['id'], unique=False)
    op.create_table('teacher_classes',
        sa.Column('teacher_id', sa.Integer(), nullable=False),
        sa.Column('class_id', sa.Integer(), nullable=False),
        sa.ForeignKeyConstraint(['class_id'], ['classes.id'], ),
        sa.ForeignKeyConstraint(['teacher_id'], ['users.id'], ),
        sa.PrimaryKeyConstraint('teacher_id', 'class_id')
    )
    op.create_table('attendance',
        sa.Column('id', sa.Integer(), nullable=False),
        sa.Column('student_id', sa.Integer(), nullable=False),
        sa.Column('class_id', sa.Integer(), nullable=False),
        sa.Column('date', sa.Date(), nullable=False),
        sa.Column('is_present', sa.Boolean(), nullable=True),
        sa.Column('remarks', sa.String(), nullable=True),
        sa.Column('marked_by', sa.Integer(), nullable=False),
        sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('(CURRENT_TIMESTAMP)'), nullable=True),
        sa.Column('updated_at', sa.DateTime(timezone=True), nullable=True),
        sa.ForeignKeyConstraint(['class_id'], ['classes.id'], ),
        sa.ForeignKeyConstraint(['marked_by'], ['users.id'], ),
        sa.ForeignKeyConstraint(['student_id'], ['users.id'], ),
        sa.PrimaryKeyConstraint('id')
    )
    op.create_index(op.f('ix_attendance_id'), 'attendance', ['id'], unique=False)
    op.create_table('grades',
        sa.Column('id', sa.Integer(), nullable=False),
        sa.Column('student_id', sa.Integer(), nullable=False),
        sa.Column('subject_id', sa.Integer(), nullable=False),
        sa.Column('score', sa.Float(), nullable=False),
        sa.Column('max_score', sa.Float(), nullable=False),
        sa.Column('grade_type', sa.String(), nullable=False),
        sa.Column('description', sa.String(), nullable=True),
        sa.Column('graded_at', sa.DateTime(timezone=True), server_default=sa.text('(CURRENT_TIMESTAMP)'), nullable=True),
        sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('(CURRENT_TIMESTAMP)'), nullable=True),
        sa.Column('updated_at', sa.DateTime(timezone=True), nullable=True),
        sa.ForeignKeyConstraint(['student_id'], ['users.id'], ),
        sa.ForeignKeyConstraint(['subject_id'], ['subjects.id'], ),
        sa.PrimaryKeyConstraint('id')
    )
    op.create_index(op.f('ix_grades_id'), 'grades', ['id'], unique=False)
    op.create_table('notifications',
        sa.Column('id', sa.Integer(), nullable=False),
        sa.Column('title', sa.String(), nullable=False),
        sa.Column('message', sa.Text(), nullable=False),
        sa.Column('sender_id', sa.Integer(), nullable=False),
        sa.Column('notification_type', sa.String(), nullable=False),
        sa.Column('priority', sa.String(), nullable=True),
        sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('(CURRENT_TIMESTAMP)'), nullable=True),
        sa.Column('updated_at', sa.DateTime(timezone=True), nullable=True),
        sa.ForeignKeyConstraint(['sender_id'], ['users.id'], ),
        sa.PrimaryKeyConstraint('id')
    )
    op.create_index(op.f('ix_notifications_id'), 'notifications', ['id'], unique=False)
    op.create_table('notification_recipients',
        sa.Column('notification_id', sa.Integer(), nullable=False),
        sa.Column('user_id', sa.Integer(), nullable=False),
        sa.Column('is_read', sa.Boolean(), nullable=True),
        sa.Column('read_at', sa.DateTime(timezone=True), nullable=True),
        sa.ForeignKeyConstraint(['notification_id'], ['notifications.id'], ),
        sa.ForeignKeyConstraint(['user_id'], ['users.id'], ),
        sa.PrimaryKeyConstraint('notification_id', 'user_id')
    )
 def downgrade() -> None:
    op.drop_table('notification_recipients')
    op.drop_index(op.f('ix_notifications_id'), table_name='notifications')
    op.drop_table('notifications')
    op.drop_index(op.f('ix_grades_id'), table_name='grades')
    op.drop_table('grades')
    op.drop_index(op.f('ix_attendance_id'), table_name='attendance')
    op.drop_table('attendance')
    op.drop_table('teacher_classes')
    op.drop_index(op.f('ix_subjects_id'), table_name='subjects')
    op.drop_table('subjects')
    op.drop_index(op.f('ix_users_id'), table_name='users')
    op.drop_index(op.f('ix_users_email'), table_name='users')
    op.drop_table('users')
    op.drop_index(op.f('ix_classes_id'), table_name='classes')
    op.drop_table('classes')
--- a/app/init.py
+++ b/app/init.py
--- a/app/api/init.py
+++ b/app/api/init.py
--- a/app/api/deps.py
+++ b/app/api/deps.py
@ -0,0 +1,62 @@
 from typing import Generator
 from fastapi import Depends, HTTPException, status
 from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
 from sqlalchemy.orm import Session
 from app.db.session import SessionLocal
 from app.core import security
 from app.models.user import User, UserRole
 from app.services.user import user_service
 security_scheme = HTTPBearer()
 def get_db() -> Generator:
    try:
        db = SessionLocal()
        yield db
    finally:
        db.close()
 def get_current_user(
    db: Session = Depends(get_db),
    credentials: HTTPAuthorizationCredentials = Depends(security_scheme)
 ) -> User:
    token = credentials.credentials
    user_id = security.verify_token(token)
    if not user_id:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Could not validate credentials",
        )
    user = user_service.get(db, id=int(user_id))
    if not user:
        raise HTTPException(status_code=404, detail="User not found")
    if not user.is_active:
        raise HTTPException(status_code=400, detail="Inactive user")
    return user
 def get_current_active_user(
    current_user: User = Depends(get_current_user),
 ) -> User:
    if not current_user.is_active:
        raise HTTPException(status_code=400, detail="Inactive user")
    return current_user
 def get_current_admin_user(
    current_user: User = Depends(get_current_user),
 ) -> User:
    if current_user.role != UserRole.ADMIN:
        raise HTTPException(
            status_code=status.HTTP_403_FORBIDDEN,
            detail="Not enough permissions"
        )
    return current_user
 def get_current_teacher_or_admin(
    current_user: User = Depends(get_current_user),
 ) -> User:
    if current_user.role not in [UserRole.TEACHER, UserRole.ADMIN]:
        raise HTTPException(
            status_code=status.HTTP_403_FORBIDDEN,
            detail="Not enough permissions"
        )
    return current_user
--- a/app/api/v1/init.py
+++ b/app/api/v1/init.py
--- a/app/api/v1/api.py
+++ b/app/api/v1/api.py
@ -0,0 +1,11 @@
 from fastapi import APIRouter
 from app.api.v1.endpoints import auth, users, classes, subjects, grades, attendance, notifications
 api_router = APIRouter()
 api_router.include_router(auth.router, prefix="/auth", tags=["authentication"])
 api_router.include_router(users.router, prefix="/users", tags=["users"])
 api_router.include_router(classes.router, prefix="/classes", tags=["classes"])
 api_router.include_router(subjects.router, prefix="/subjects", tags=["subjects"])
 api_router.include_router(grades.router, prefix="/grades", tags=["grades"])
 api_router.include_router(attendance.router, prefix="/attendance", tags=["attendance"])
 api_router.include_router(notifications.router, prefix="/notifications", tags=["notifications"])
--- a/app/api/v1/endpoints/init.py
+++ b/app/api/v1/endpoints/init.py
--- a/app/api/v1/endpoints/attendance.py
+++ b/app/api/v1/endpoints/attendance.py
@ -0,0 +1,83 @@
 from typing import Any, List
 from fastapi import APIRouter, Depends, HTTPException
 from sqlalchemy.orm import Session
 from datetime import date
 from app.api import deps
 from app.models.user import User, UserRole
 from app.schemas.attendance import Attendance, AttendanceCreate, AttendanceUpdate
 from app.services.attendance import attendance_service
 router = APIRouter()
@router.get("/", response_model=List[Attendance])
 def read_attendance(
    db: Session = Depends(deps.get_db),
    skip: int = 0,
    limit: int = 100,
    student_id: int = None,
    class_id: int = None,
    date: date = None,
    current_user: User = Depends(deps.get_current_active_user),
 ) -> Any:
    if current_user.role == UserRole.STUDENT:
        attendance = attendance_service.get_by_student(db, student_id=current_user.id)
    elif current_user.role == UserRole.PARENT:
        if not student_id:
            raise HTTPException(status_code=400, detail="Parent must specify student_id")
        attendance = attendance_service.get_by_student(db, student_id=student_id)
    elif student_id and date:
        attendance = [attendance_service.get_by_student_and_date(db, student_id=student_id, date=date)]
    elif student_id:
        attendance = attendance_service.get_by_student(db, student_id=student_id)
    elif class_id:
        attendance = attendance_service.get_by_class(db, class_id=class_id)
    elif date:
        attendance = attendance_service.get_by_date(db, date=date)
    else:
        attendance = attendance_service.get_multi(db, skip=skip, limit=limit)
    return [a for a in attendance if a is not None]
@router.post("/", response_model=Attendance)
 def create_attendance(
    *,
    db: Session = Depends(deps.get_db),
    attendance_in: AttendanceCreate,
    current_user: User = Depends(deps.get_current_teacher_or_admin),
 ) -> Any:
    attendance = attendance_service.create_with_teacher(
        db, obj_in=attendance_in, teacher_id=current_user.id
    )
    return attendance
@router.put("/{attendance_id}", response_model=Attendance)
 def update_attendance(
    *,
    db: Session = Depends(deps.get_db),
    attendance_id: int,
    attendance_in: AttendanceUpdate,
    current_user: User = Depends(deps.get_current_teacher_or_admin),
 ) -> Any:
    attendance = attendance_service.get(db, id=attendance_id)
    if not attendance:
        raise HTTPException(status_code=404, detail="Attendance not found")
    attendance = attendance_service.update(db, db_obj=attendance, obj_in=attendance_in)
    return attendance
@router.get("/{attendance_id}", response_model=Attendance)
 def read_attendance_record(
    *,
    db: Session = Depends(deps.get_db),
    attendance_id: int,
    current_user: User = Depends(deps.get_current_active_user),
 ) -> Any:
    attendance = attendance_service.get(db, id=attendance_id)
    if not attendance:
        raise HTTPException(status_code=404, detail="Attendance not found")
    if current_user.role == UserRole.STUDENT and attendance.student_id != current_user.id:
        raise HTTPException(status_code=403, detail="Not enough permissions")
    elif current_user.role == UserRole.PARENT and attendance.student.parent_id != current_user.id:
        raise HTTPException(status_code=403, detail="Not enough permissions")
    return attendance
--- a/app/api/v1/endpoints/auth.py
+++ b/app/api/v1/endpoints/auth.py
@ -0,0 +1,60 @@
 from datetime import timedelta
 from typing import Any
 from fastapi import APIRouter, Depends, HTTPException, status
 from fastapi.security import OAuth2PasswordRequestForm
 from sqlalchemy.orm import Session
 from app.api import deps
 from app.core import security
 from app.core.config import settings
 from app.schemas.token import Token
 from app.schemas.user import User, UserCreate
 from app.services.user import user_service
 router = APIRouter()
@router.post("/login", response_model=Token)
 def login_for_access_token(
    db: Session = Depends(deps.get_db), form_data: OAuth2PasswordRequestForm = Depends()
 ) -> Any:
    user = user_service.authenticate(
        db, email=form_data.username, password=form_data.password
    )
    if not user:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Incorrect email or password",
            headers={"WWW-Authenticate": "Bearer"},
        )
    elif not user_service.is_active(user):
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST, detail="Inactive user"
        )
    access_token_expires = timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)
    return {
        "access_token": security.create_access_token(
            user.id, expires_delta=access_token_expires
        ),
        "token_type": "bearer",
    }
@router.post("/register", response_model=User)
 def register_user(
    *,
    db: Session = Depends(deps.get_db),
    user_in: UserCreate,
 ) -> Any:
    user = user_service.get_by_email(db, email=user_in.email)
    if user:
        raise HTTPException(
            status_code=400,
            detail="The user with this email already exists in the system.",
        )
    user = user_service.create(db, obj_in=user_in)
    return user
@router.get("/me", response_model=User)
 def read_users_me(
    db: Session = Depends(deps.get_db),
    current_user: User = Depends(deps.get_current_active_user),
 ) -> Any:
    return current_user
--- a/app/api/v1/endpoints/classes.py
+++ b/app/api/v1/endpoints/classes.py
@ -0,0 +1,68 @@
 from typing import Any, List
 from fastapi import APIRouter, Depends, HTTPException
 from sqlalchemy.orm import Session
 from app.api import deps
 from app.models.user import User
 from app.schemas.class_schema import Class, ClassCreate, ClassUpdate
 from app.services.class_service import class_service
 router = APIRouter()
@router.get("/", response_model=List[Class])
 def read_classes(
    db: Session = Depends(deps.get_db),
    skip: int = 0,
    limit: int = 100,
    current_user: User = Depends(deps.get_current_active_user),
 ) -> Any:
    classes = class_service.get_multi(db, skip=skip, limit=limit)
    return classes
@router.post("/", response_model=Class)
 def create_class(
    *,
    db: Session = Depends(deps.get_db),
    class_in: ClassCreate,
    current_user: User = Depends(deps.get_current_admin_user),
 ) -> Any:
    class_obj = class_service.create(db, obj_in=class_in)
    return class_obj
@router.put("/{class_id}", response_model=Class)
 def update_class(
    *,
    db: Session = Depends(deps.get_db),
    class_id: int,
    class_in: ClassUpdate,
    current_user: User = Depends(deps.get_current_admin_user),
 ) -> Any:
    class_obj = class_service.get(db, id=class_id)
    if not class_obj:
        raise HTTPException(status_code=404, detail="Class not found")
    class_obj = class_service.update(db, db_obj=class_obj, obj_in=class_in)
    return class_obj
@router.get("/{class_id}", response_model=Class)
 def read_class(
    *,
    db: Session = Depends(deps.get_db),
    class_id: int,
    current_user: User = Depends(deps.get_current_active_user),
 ) -> Any:
    class_obj = class_service.get(db, id=class_id)
    if not class_obj:
        raise HTTPException(status_code=404, detail="Class not found")
    return class_obj
@router.delete("/{class_id}", response_model=Class)
 def delete_class(
    *,
    db: Session = Depends(deps.get_db),
    class_id: int,
    current_user: User = Depends(deps.get_current_admin_user),
 ) -> Any:
    class_obj = class_service.get(db, id=class_id)
    if not class_obj:
        raise HTTPException(status_code=404, detail="Class not found")
    class_obj = class_service.remove(db, id=class_id)
    return class_obj
--- a/app/api/v1/endpoints/grades.py
+++ b/app/api/v1/endpoints/grades.py
@ -0,0 +1,90 @@
 from typing import Any, List
 from fastapi import APIRouter, Depends, HTTPException
 from sqlalchemy.orm import Session
 from app.api import deps
 from app.models.user import User, UserRole
 from app.schemas.grade import Grade, GradeCreate, GradeUpdate
 from app.services.grade import grade_service
 router = APIRouter()
@router.get("/", response_model=List[Grade])
 def read_grades(
    db: Session = Depends(deps.get_db),
    skip: int = 0,
    limit: int = 100,
    student_id: int = None,
    subject_id: int = None,
    current_user: User = Depends(deps.get_current_active_user),
 ) -> Any:
    if current_user.role == UserRole.STUDENT:
        grades = grade_service.get_by_student(db, student_id=current_user.id)
    elif current_user.role == UserRole.PARENT:
        if not student_id:
            raise HTTPException(status_code=400, detail="Parent must specify student_id")
        grades = grade_service.get_by_student(db, student_id=student_id)
    elif student_id and subject_id:
        grades = grade_service.get_by_student_and_subject(db, student_id=student_id, subject_id=subject_id)
    elif student_id:
        grades = grade_service.get_by_student(db, student_id=student_id)
    elif subject_id:
        grades = grade_service.get_by_subject(db, subject_id=subject_id)
    else:
        grades = grade_service.get_multi(db, skip=skip, limit=limit)
    return grades
@router.post("/", response_model=Grade)
 def create_grade(
    *,
    db: Session = Depends(deps.get_db),
    grade_in: GradeCreate,
    current_user: User = Depends(deps.get_current_teacher_or_admin),
 ) -> Any:
    grade = grade_service.create(db, obj_in=grade_in)
    return grade
@router.put("/{grade_id}", response_model=Grade)
 def update_grade(
    *,
    db: Session = Depends(deps.get_db),
    grade_id: int,
    grade_in: GradeUpdate,
    current_user: User = Depends(deps.get_current_teacher_or_admin),
 ) -> Any:
    grade = grade_service.get(db, id=grade_id)
    if not grade:
        raise HTTPException(status_code=404, detail="Grade not found")
    grade = grade_service.update(db, db_obj=grade, obj_in=grade_in)
    return grade
@router.get("/{grade_id}", response_model=Grade)
 def read_grade(
    *,
    db: Session = Depends(deps.get_db),
    grade_id: int,
    current_user: User = Depends(deps.get_current_active_user),
 ) -> Any:
    grade = grade_service.get(db, id=grade_id)
    if not grade:
        raise HTTPException(status_code=404, detail="Grade not found")
    if current_user.role == UserRole.STUDENT and grade.student_id != current_user.id:
        raise HTTPException(status_code=403, detail="Not enough permissions")
    elif current_user.role == UserRole.PARENT and grade.student.parent_id != current_user.id:
        raise HTTPException(status_code=403, detail="Not enough permissions")
    return grade
@router.delete("/{grade_id}", response_model=Grade)
 def delete_grade(
    *,
    db: Session = Depends(deps.get_db),
    grade_id: int,
    current_user: User = Depends(deps.get_current_teacher_or_admin),
 ) -> Any:
    grade = grade_service.get(db, id=grade_id)
    if not grade:
        raise HTTPException(status_code=404, detail="Grade not found")
    grade = grade_service.remove(db, id=grade_id)
    return grade
--- a/app/api/v1/endpoints/notifications.py
+++ b/app/api/v1/endpoints/notifications.py
@ -0,0 +1,82 @@
 from typing import Any, List
 from fastapi import APIRouter, Depends, HTTPException
 from sqlalchemy.orm import Session
 from app.api import deps
 from app.models.user import User, UserRole
 from app.schemas.notification import Notification, NotificationCreate, NotificationUpdate
 from app.services.notification import notification_service
 router = APIRouter()
@router.get("/", response_model=List[Notification])
 def read_notifications(
    db: Session = Depends(deps.get_db),
    skip: int = 0,
    limit: int = 100,
    current_user: User = Depends(deps.get_current_active_user),
 ) -> Any:
    if current_user.role in [UserRole.STUDENT, UserRole.PARENT]:
        notifications = notification_service.get_by_recipient(db, recipient_id=current_user.id)
    else:
        notifications = notification_service.get_multi(db, skip=skip, limit=limit)
    return notifications
@router.post("/", response_model=Notification)
 def create_notification(
    *,
    db: Session = Depends(deps.get_db),
    notification_in: NotificationCreate,
    current_user: User = Depends(deps.get_current_teacher_or_admin),
 ) -> Any:
    notification = notification_service.create_with_recipients(
        db, obj_in=notification_in, sender_id=current_user.id
    )
    return notification
@router.put("/{notification_id}", response_model=Notification)
 def update_notification(
    *,
    db: Session = Depends(deps.get_db),
    notification_id: int,
    notification_in: NotificationUpdate,
    current_user: User = Depends(deps.get_current_teacher_or_admin),
 ) -> Any:
    notification = notification_service.get(db, id=notification_id)
    if not notification:
        raise HTTPException(status_code=404, detail="Notification not found")
    if notification.sender_id != current_user.id and current_user.role != UserRole.ADMIN:
        raise HTTPException(status_code=403, detail="Not enough permissions")
    notification = notification_service.update(db, db_obj=notification, obj_in=notification_in)
    return notification
@router.get("/{notification_id}", response_model=Notification)
 def read_notification(
    *,
    db: Session = Depends(deps.get_db),
    notification_id: int,
    current_user: User = Depends(deps.get_current_active_user),
 ) -> Any:
    notification = notification_service.get(db, id=notification_id)
    if not notification:
        raise HTTPException(status_code=404, detail="Notification not found")
    return notification
@router.delete("/{notification_id}", response_model=Notification)
 def delete_notification(
    *,
    db: Session = Depends(deps.get_db),
    notification_id: int,
    current_user: User = Depends(deps.get_current_teacher_or_admin),
 ) -> Any:
    notification = notification_service.get(db, id=notification_id)
    if not notification:
        raise HTTPException(status_code=404, detail="Notification not found")
    if notification.sender_id != current_user.id and current_user.role != UserRole.ADMIN:
        raise HTTPException(status_code=403, detail="Not enough permissions") 
    notification = notification_service.remove(db, id=notification_id)
    return notification
--- a/app/api/v1/endpoints/subjects.py
+++ b/app/api/v1/endpoints/subjects.py
@ -0,0 +1,68 @@
 from typing import Any, List
 from fastapi import APIRouter, Depends, HTTPException
 from sqlalchemy.orm import Session
 from app.api import deps
 from app.models.user import User
 from app.schemas.subject import Subject, SubjectCreate, SubjectUpdate
 from app.services.subject import subject_service
 router = APIRouter()
@router.get("/", response_model=List[Subject])
 def read_subjects(
    db: Session = Depends(deps.get_db),
    skip: int = 0,
    limit: int = 100,
    current_user: User = Depends(deps.get_current_active_user),
 ) -> Any:
    subjects = subject_service.get_multi(db, skip=skip, limit=limit)
    return subjects
@router.post("/", response_model=Subject)
 def create_subject(
    *,
    db: Session = Depends(deps.get_db),
    subject_in: SubjectCreate,
    current_user: User = Depends(deps.get_current_admin_user),
 ) -> Any:
    subject = subject_service.create(db, obj_in=subject_in)
    return subject
@router.put("/{subject_id}", response_model=Subject)
 def update_subject(
    *,
    db: Session = Depends(deps.get_db),
    subject_id: int,
    subject_in: SubjectUpdate,
    current_user: User = Depends(deps.get_current_admin_user),
 ) -> Any:
    subject = subject_service.get(db, id=subject_id)
    if not subject:
        raise HTTPException(status_code=404, detail="Subject not found")
    subject = subject_service.update(db, db_obj=subject, obj_in=subject_in)
    return subject
@router.get("/{subject_id}", response_model=Subject)
 def read_subject(
    *,
    db: Session = Depends(deps.get_db),
    subject_id: int,
    current_user: User = Depends(deps.get_current_active_user),
 ) -> Any:
    subject = subject_service.get(db, id=subject_id)
    if not subject:
        raise HTTPException(status_code=404, detail="Subject not found")
    return subject
@router.delete("/{subject_id}", response_model=Subject)
 def delete_subject(
    *,
    db: Session = Depends(deps.get_db),
    subject_id: int,
    current_user: User = Depends(deps.get_current_admin_user),
 ) -> Any:
    subject = subject_service.get(db, id=subject_id)
    if not subject:
        raise HTTPException(status_code=404, detail="Subject not found")
    subject = subject_service.remove(db, id=subject_id)
    return subject
--- a/app/api/v1/endpoints/users.py
+++ b/app/api/v1/endpoints/users.py
@ -0,0 +1,115 @@
 from typing import Any, List
 from fastapi import APIRouter, Depends, HTTPException
 from sqlalchemy.orm import Session
 from app.api import deps
 from app.models.user import User, UserRole
 from app.schemas.user import User as UserSchema, UserCreate, UserUpdate
 from app.services.user import user_service
 router = APIRouter()
@router.get("/", response_model=List[UserSchema])
 def read_users(
    db: Session = Depends(deps.get_db),
    skip: int = 0,
    limit: int = 100,
    current_user: User = Depends(deps.get_current_admin_user),
 ) -> Any:
    users = user_service.get_multi(db, skip=skip, limit=limit)
    return users
@router.post("/", response_model=UserSchema)
 def create_user(
    *,
    db: Session = Depends(deps.get_db),
    user_in: UserCreate,
    current_user: User = Depends(deps.get_current_admin_user),
 ) -> Any:
    user = user_service.get_by_email(db, email=user_in.email)
    if user:
        raise HTTPException(
            status_code=400,
            detail="The user with this email already exists in the system",
        )
    user = user_service.create(db, obj_in=user_in)
    return user
@router.put("/{user_id}", response_model=UserSchema)
 def update_user(
    *,
    db: Session = Depends(deps.get_db),
    user_id: int,
    user_in: UserUpdate,
    current_user: User = Depends(deps.get_current_teacher_or_admin),
 ) -> Any:
    user = user_service.get(db, id=user_id)
    if not user:
        raise HTTPException(
            status_code=404,
            detail="The user with this id does not exist in the system",
        )
    if current_user.role == UserRole.TEACHER and user_in.role and user_in.role != UserRole.STUDENT:
        raise HTTPException(
            status_code=403,
            detail="Teachers can only modify student profiles"
        )
    user = user_service.update(db, db_obj=user, obj_in=user_in)
    return user
@router.get("/{user_id}", response_model=UserSchema)
 def read_user(
    *,
    db: Session = Depends(deps.get_db),
    user_id: int,
    current_user: User = Depends(deps.get_current_active_user),
 ) -> Any:
    user = user_service.get(db, id=user_id)
    if not user:
        raise HTTPException(status_code=404, detail="User not found")
    if current_user.role not in [UserRole.ADMIN, UserRole.TEACHER] and current_user.id != user_id:
        raise HTTPException(status_code=403, detail="Not enough permissions")
    return user
@router.delete("/{user_id}", response_model=UserSchema)
 def delete_user(
    *,
    db: Session = Depends(deps.get_db),
    user_id: int,
    current_user: User = Depends(deps.get_current_teacher_or_admin),
 ) -> Any:
    user = user_service.get(db, id=user_id)
    if not user:
        raise HTTPException(status_code=404, detail="User not found")
    if current_user.role == UserRole.TEACHER and user.role != UserRole.STUDENT:
        raise HTTPException(
            status_code=403,
            detail="Teachers can only delete student profiles"
        )
    user = user_service.remove(db, id=user_id)
    return user
@router.get("/students/", response_model=List[UserSchema])
 def read_students(
    db: Session = Depends(deps.get_db),
    skip: int = 0,
    limit: int = 100,
    current_user: User = Depends(deps.get_current_teacher_or_admin),
 ) -> Any:
    students = user_service.get_students(db, skip=skip, limit=limit)
    return students
@router.get("/teachers/", response_model=List[UserSchema])
 def read_teachers(
    db: Session = Depends(deps.get_db),
    skip: int = 0,
    limit: int = 100,
    current_user: User = Depends(deps.get_current_admin_user),
 ) -> Any:
    teachers = user_service.get_teachers(db, skip=skip, limit=limit)
    return teachers
--- a/app/core/init.py
+++ b/app/core/init.py
--- a/app/core/config.py
+++ b/app/core/config.py
@ -0,0 +1,20 @@
 import os
 from pydantic import BaseSettings
 class Settings(BaseSettings):
    PROJECT_NAME: str = "School Portal API"
    VERSION: str = "1.0.0"
    API_V1_STR: str = "/api/v1"
    SECRET_KEY: str = os.getenv("SECRET_KEY", "your-secret-key-change-in-production")
    ACCESS_TOKEN_EXPIRE_MINUTES: int = 60 * 24 * 8  # 8 days
    DATABASE_URL: str = os.getenv("DATABASE_URL", "sqlite:////app/storage/db/db.sqlite")
    FIRST_SUPERUSER_EMAIL: str = os.getenv("FIRST_SUPERUSER_EMAIL", "admin@schoolportal.com")
    FIRST_SUPERUSER_PASSWORD: str = os.getenv("FIRST_SUPERUSER_PASSWORD", "admin123")
    class Config:
        case_sensitive = True
 settings = Settings()
--- a/app/core/security.py
+++ b/app/core/security.py
@ -0,0 +1,38 @@
 from datetime import datetime, timedelta
 from typing import Optional, Union
 from jose import JWTError, jwt
 from passlib.context import CryptContext
 from app.core.config import settings
 pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
 ALGORITHM = "HS256"
 def create_access_token(
    subject: Union[str, int], expires_delta: Optional[timedelta] = None
 ):
    if expires_delta:
        expire = datetime.utcnow() + expires_delta
    else:
        expire = datetime.utcnow() + timedelta(
            minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES
        )
    to_encode = {"exp": expire, "sub": str(subject)}
    encoded_jwt = jwt.encode(to_encode, settings.SECRET_KEY, algorithm=ALGORITHM)
    return encoded_jwt
 def verify_password(plain_password: str, hashed_password: str) -> bool:
    return pwd_context.verify(plain_password, hashed_password)
 def get_password_hash(password: str) -> str:
    return pwd_context.hash(password)
 def verify_token(token: str) -> Optional[str]:
    try:
        payload = jwt.decode(token, settings.SECRET_KEY, algorithms=[ALGORITHM])
        user_id: str = payload.get("sub")
        if user_id is None:
            return None
        return user_id
    except JWTError:
        return None
--- a/app/db/init.py
+++ b/app/db/init.py
--- a/app/db/base.py
+++ b/app/db/base.py
@ -0,0 +1,3 @@
 from sqlalchemy.ext.declarative import declarative_base
 Base = declarative_base()
--- a/app/db/session.py
+++ b/app/db/session.py
@ -0,0 +1,15 @@
 from pathlib import Path
 from sqlalchemy import create_engine
 from sqlalchemy.orm import sessionmaker
 DB_DIR = Path("/app/storage/db")
 DB_DIR.mkdir(parents=True, exist_ok=True)
 SQLALCHEMY_DATABASE_URL = f"sqlite:///{DB_DIR}/db.sqlite"
 engine = create_engine(
    SQLALCHEMY_DATABASE_URL,
    connect_args={"check_same_thread": False}
 )
 SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
--- a/app/models/init.py
+++ b/app/models/init.py
@ -0,0 +1,8 @@
 from .user import User
 from .class_model import Class
 from .subject import Subject
 from .grade import Grade
 from .attendance import Attendance
 from .notification import Notification
 __all__ = ["User", "Class", "Subject", "Grade", "Attendance", "Notification"]
--- a/app/models/attendance.py
+++ b/app/models/attendance.py
@ -0,0 +1,21 @@
 from sqlalchemy import Column, Integer, String, DateTime, ForeignKey, Date, Boolean
 from sqlalchemy.orm import relationship
 from sqlalchemy.sql import func
 from app.db.base import Base
 class Attendance(Base):
    __tablename__ = "attendance"
    id = Column(Integer, primary_key=True, index=True)
    student_id = Column(Integer, ForeignKey("users.id"), nullable=False)
    class_id = Column(Integer, ForeignKey("classes.id"), nullable=False)
    date = Column(Date, nullable=False)
    is_present = Column(Boolean, default=False)
    remarks = Column(String)
    marked_by = Column(Integer, ForeignKey("users.id"), nullable=False)
    created_at = Column(DateTime(timezone=True), server_default=func.now())
    updated_at = Column(DateTime(timezone=True), onupdate=func.now())
    student = relationship("User", foreign_keys=[student_id], back_populates="attendance_records")
    class_ref = relationship("Class", back_populates="attendance_records")
    teacher = relationship("User", foreign_keys=[marked_by])
--- a/app/models/class_model.py
+++ b/app/models/class_model.py
@ -0,0 +1,26 @@
 from sqlalchemy import Column, Integer, String, DateTime, Table, ForeignKey
 from sqlalchemy.orm import relationship
 from sqlalchemy.sql import func
 from app.db.base import Base
 teacher_classes = Table(
    "teacher_classes",
    Base.metadata,
    Column("teacher_id", Integer, ForeignKey("users.id"), primary_key=True),
    Column("class_id", Integer, ForeignKey("classes.id"), primary_key=True),
 )
 class Class(Base):
    __tablename__ = "classes"
    id = Column(Integer, primary_key=True, index=True)
    name = Column(String, nullable=False)
    grade_level = Column(String, nullable=False)
    academic_year = Column(String, nullable=False)
    created_at = Column(DateTime(timezone=True), server_default=func.now())
    updated_at = Column(DateTime(timezone=True), onupdate=func.now())
    students = relationship("User", back_populates="assigned_class")
    teachers = relationship("User", secondary=teacher_classes, back_populates="taught_classes")
    subjects = relationship("Subject", back_populates="class_ref")
    attendance_records = relationship("Attendance", back_populates="class_ref")
--- a/app/models/grade.py
+++ b/app/models/grade.py
@ -0,0 +1,21 @@
 from sqlalchemy import Column, Integer, String, DateTime, ForeignKey, Float
 from sqlalchemy.orm import relationship
 from sqlalchemy.sql import func
 from app.db.base import Base
 class Grade(Base):
    __tablename__ = "grades"
    id = Column(Integer, primary_key=True, index=True)
    student_id = Column(Integer, ForeignKey("users.id"), nullable=False)
    subject_id = Column(Integer, ForeignKey("subjects.id"), nullable=False)
    score = Column(Float, nullable=False)
    max_score = Column(Float, nullable=False, default=100.0)
    grade_type = Column(String, nullable=False)  # quiz, exam, assignment, etc.
    description = Column(String)
    graded_at = Column(DateTime(timezone=True), server_default=func.now())
    created_at = Column(DateTime(timezone=True), server_default=func.now())
    updated_at = Column(DateTime(timezone=True), onupdate=func.now())
    student = relationship("User", back_populates="grades")
    subject = relationship("Subject", back_populates="grades")
--- a/app/models/notification.py
+++ b/app/models/notification.py
@ -0,0 +1,28 @@
 from sqlalchemy import Column, Integer, String, DateTime, ForeignKey, Boolean, Text, Table
 from sqlalchemy.orm import relationship
 from sqlalchemy.sql import func
 from app.db.base import Base
 notification_recipients = Table(
    "notification_recipients",
    Base.metadata,
    Column("notification_id", Integer, ForeignKey("notifications.id"), primary_key=True),
    Column("user_id", Integer, ForeignKey("users.id"), primary_key=True),
    Column("is_read", Boolean, default=False),
    Column("read_at", DateTime(timezone=True))
 )
 class Notification(Base):
    __tablename__ = "notifications"
    id = Column(Integer, primary_key=True, index=True)
    title = Column(String, nullable=False)
    message = Column(Text, nullable=False)
    sender_id = Column(Integer, ForeignKey("users.id"), nullable=False)
    notification_type = Column(String, nullable=False)  # announcement, message, alert
    priority = Column(String, default="normal")  # low, normal, high, urgent
    created_at = Column(DateTime(timezone=True), server_default=func.now())
    updated_at = Column(DateTime(timezone=True), onupdate=func.now())
    sender = relationship("User", foreign_keys=[sender_id], back_populates="sent_notifications")
    recipients = relationship("User", secondary=notification_recipients, back_populates="received_notifications")
--- a/app/models/subject.py
+++ b/app/models/subject.py
@ -0,0 +1,20 @@
 from sqlalchemy import Column, Integer, String, DateTime, ForeignKey
 from sqlalchemy.orm import relationship
 from sqlalchemy.sql import func
 from app.db.base import Base
 class Subject(Base):
    __tablename__ = "subjects"
    id = Column(Integer, primary_key=True, index=True)
    name = Column(String, nullable=False)
    code = Column(String, unique=True, nullable=False)
    description = Column(String)
    class_id = Column(Integer, ForeignKey("classes.id"), nullable=False)
    teacher_id = Column(Integer, ForeignKey("users.id"), nullable=False)
    created_at = Column(DateTime(timezone=True), server_default=func.now())
    updated_at = Column(DateTime(timezone=True), onupdate=func.now())
    class_ref = relationship("Class", back_populates="subjects")
    teacher = relationship("User")
    grades = relationship("Grade", back_populates="subject")
--- a/app/models/user.py
+++ b/app/models/user.py
@ -0,0 +1,35 @@
 from sqlalchemy import Column, Integer, String, Boolean, DateTime, Enum, ForeignKey
 from sqlalchemy.orm import relationship
 from sqlalchemy.sql import func
 import enum
 from app.db.base import Base
 class UserRole(str, enum.Enum):
    ADMIN = "admin"
    TEACHER = "teacher"
    STUDENT = "student"
    PARENT = "parent"
 class User(Base):
    __tablename__ = "users"
    id = Column(Integer, primary_key=True, index=True)
    email = Column(String, unique=True, index=True, nullable=False)
    hashed_password = Column(String, nullable=False)
    first_name = Column(String, nullable=False)
    last_name = Column(String, nullable=False)
    role = Column(Enum(UserRole), nullable=False)
    is_active = Column(Boolean, default=True)
    created_at = Column(DateTime(timezone=True), server_default=func.now())
    updated_at = Column(DateTime(timezone=True), onupdate=func.now())
    parent_id = Column(Integer, ForeignKey("users.id"), nullable=True)
    class_id = Column(Integer, ForeignKey("classes.id"), nullable=True)
    parent = relationship("User", remote_side=[id], backref="children")
    assigned_class = relationship("Class", back_populates="students")
    taught_classes = relationship("Class", secondary="teacher_classes", back_populates="teachers")
    grades = relationship("Grade", back_populates="student")
    attendance_records = relationship("Attendance", back_populates="student")
    sent_notifications = relationship("Notification", foreign_keys="Notification.sender_id", back_populates="sender")
    received_notifications = relationship("Notification", secondary="notification_recipients", back_populates="recipients")
--- a/app/schemas/init.py
+++ b/app/schemas/init.py
@ -0,0 +1,17 @@
 from .user import User, UserCreate, UserUpdate, UserInDB
 from .class_schema import Class, ClassCreate, ClassUpdate
 from .subject import Subject, SubjectCreate, SubjectUpdate
 from .grade import Grade, GradeCreate, GradeUpdate
 from .attendance import Attendance, AttendanceCreate, AttendanceUpdate
 from .notification import Notification, NotificationCreate, NotificationUpdate
 from .token import Token, TokenPayload
 __all__ = [
    "User", "UserCreate", "UserUpdate", "UserInDB",
    "Class", "ClassCreate", "ClassUpdate",
    "Subject", "SubjectCreate", "SubjectUpdate",
    "Grade", "GradeCreate", "GradeUpdate",
    "Attendance", "AttendanceCreate", "AttendanceUpdate",
    "Notification", "NotificationCreate", "NotificationUpdate",
    "Token", "TokenPayload"
 ]
--- a/app/schemas/attendance.py
+++ b/app/schemas/attendance.py
@ -0,0 +1,29 @@
 from typing import Optional
 from pydantic import BaseModel
 from datetime import datetime, date
 class AttendanceBase(BaseModel):
    student_id: int
    class_id: int
    date: date
    is_present: bool = False
    remarks: Optional[str] = None
 class AttendanceCreate(AttendanceBase):
    pass
 class AttendanceUpdate(BaseModel):
    is_present: Optional[bool] = None
    remarks: Optional[str] = None
 class AttendanceInDBBase(AttendanceBase):
    id: int
    marked_by: int
    created_at: datetime
    updated_at: Optional[datetime] = None
    class Config:
        orm_mode = True
 class Attendance(AttendanceInDBBase):
    pass
--- a/app/schemas/class_schema.py
+++ b/app/schemas/class_schema.py
@ -0,0 +1,27 @@
 from typing import Optional
 from pydantic import BaseModel
 from datetime import datetime
 class ClassBase(BaseModel):
    name: str
    grade_level: str
    academic_year: str
 class ClassCreate(ClassBase):
    pass
 class ClassUpdate(BaseModel):
    name: Optional[str] = None
    grade_level: Optional[str] = None
    academic_year: Optional[str] = None
 class ClassInDBBase(ClassBase):
    id: int
    created_at: datetime
    updated_at: Optional[datetime] = None
    class Config:
        orm_mode = True
 class Class(ClassInDBBase):
    pass
--- a/app/schemas/grade.py
+++ b/app/schemas/grade.py
@ -0,0 +1,32 @@
 from typing import Optional
 from pydantic import BaseModel
 from datetime import datetime
 class GradeBase(BaseModel):
    student_id: int
    subject_id: int
    score: float
    max_score: float = 100.0
    grade_type: str
    description: Optional[str] = None
 class GradeCreate(GradeBase):
    pass
 class GradeUpdate(BaseModel):
    score: Optional[float] = None
    max_score: Optional[float] = None
    grade_type: Optional[str] = None
    description: Optional[str] = None
 class GradeInDBBase(GradeBase):
    id: int
    graded_at: datetime
    created_at: datetime
    updated_at: Optional[datetime] = None
    class Config:
        orm_mode = True
 class Grade(GradeInDBBase):
    pass
--- a/app/schemas/notification.py
+++ b/app/schemas/notification.py
@ -0,0 +1,30 @@
 from typing import Optional, List
 from pydantic import BaseModel
 from datetime import datetime
 class NotificationBase(BaseModel):
    title: str
    message: str
    notification_type: str
    priority: str = "normal"
 class NotificationCreate(NotificationBase):
    recipient_ids: List[int]
 class NotificationUpdate(BaseModel):
    title: Optional[str] = None
    message: Optional[str] = None
    notification_type: Optional[str] = None
    priority: Optional[str] = None
 class NotificationInDBBase(NotificationBase):
    id: int
    sender_id: int
    created_at: datetime
    updated_at: Optional[datetime] = None
    class Config:
        orm_mode = True
 class Notification(NotificationInDBBase):
    pass
--- a/app/schemas/subject.py
+++ b/app/schemas/subject.py
@ -0,0 +1,31 @@
 from typing import Optional
 from pydantic import BaseModel
 from datetime import datetime
 class SubjectBase(BaseModel):
    name: str
    code: str
    description: Optional[str] = None
    class_id: int
    teacher_id: int
 class SubjectCreate(SubjectBase):
    pass
 class SubjectUpdate(BaseModel):
    name: Optional[str] = None
    code: Optional[str] = None
    description: Optional[str] = None
    class_id: Optional[int] = None
    teacher_id: Optional[int] = None
 class SubjectInDBBase(SubjectBase):
    id: int
    created_at: datetime
    updated_at: Optional[datetime] = None
    class Config:
        orm_mode = True
 class Subject(SubjectInDBBase):
    pass
--- a/app/schemas/token.py
+++ b/app/schemas/token.py
@ -0,0 +1,9 @@
 from typing import Optional
 from pydantic import BaseModel
 class Token(BaseModel):
    access_token: str
    token_type: str
 class TokenPayload(BaseModel):
    sub: Optional[int] = None
--- a/app/schemas/user.py
+++ b/app/schemas/user.py
@ -0,0 +1,40 @@
 from typing import Optional
 from pydantic import BaseModel, EmailStr
 from datetime import datetime
 from app.models.user import UserRole
 class UserBase(BaseModel):
    email: EmailStr
    first_name: str
    last_name: str
    role: UserRole
    is_active: bool = True
    parent_id: Optional[int] = None
    class_id: Optional[int] = None
 class UserCreate(UserBase):
    password: str
 class UserUpdate(BaseModel):
    email: Optional[EmailStr] = None
    first_name: Optional[str] = None
    last_name: Optional[str] = None
    role: Optional[UserRole] = None
    is_active: Optional[bool] = None
    parent_id: Optional[int] = None
    class_id: Optional[int] = None
    password: Optional[str] = None
 class UserInDBBase(UserBase):
    id: int
    created_at: datetime
    updated_at: Optional[datetime] = None
    class Config:
        orm_mode = True
 class User(UserInDBBase):
    pass
 class UserInDB(UserInDBBase):
    hashed_password: str
--- a/app/services/init.py
+++ b/app/services/init.py
--- a/app/services/attendance.py
+++ b/app/services/attendance.py
@ -0,0 +1,33 @@
 from typing import List
 from sqlalchemy.orm import Session
 from datetime import date
 from app.models.attendance import Attendance
 from app.schemas.attendance import AttendanceCreate, AttendanceUpdate
 from app.services.base import CRUDBase
 class CRUDAttendance(CRUDBase[Attendance, AttendanceCreate, AttendanceUpdate]):
    def get_by_student(self, db: Session, *, student_id: int) -> List[Attendance]:
        return db.query(Attendance).filter(Attendance.student_id == student_id).all()
    def get_by_class(self, db: Session, *, class_id: int) -> List[Attendance]:
        return db.query(Attendance).filter(Attendance.class_id == class_id).all()
    def get_by_date(self, db: Session, *, date: date) -> List[Attendance]:
        return db.query(Attendance).filter(Attendance.date == date).all()
    def get_by_student_and_date(self, db: Session, *, student_id: int, date: date) -> Attendance:
        return db.query(Attendance).filter(
            Attendance.student_id == student_id,
            Attendance.date == date
        ).first()
    def create_with_teacher(self, db: Session, *, obj_in: AttendanceCreate, teacher_id: int) -> Attendance:
        obj_in_data = obj_in.dict()
        obj_in_data["marked_by"] = teacher_id
        db_obj = Attendance(**obj_in_data)
        db.add(db_obj)
        db.commit()
        db.refresh(db_obj)
        return db_obj
 attendance_service = CRUDAttendance(Attendance)
--- a/app/services/base.py
+++ b/app/services/base.py
@ -0,0 +1,55 @@
 from typing import Any, Dict, Generic, List, Optional, Type, TypeVar, Union
 from fastapi.encoders import jsonable_encoder
 from pydantic import BaseModel
 from sqlalchemy.orm import Session
 from app.db.base import Base
 ModelType = TypeVar("ModelType", bound=Base)
 CreateSchemaType = TypeVar("CreateSchemaType", bound=BaseModel)
 UpdateSchemaType = TypeVar("UpdateSchemaType", bound=BaseModel)
 class CRUDBase(Generic[ModelType, CreateSchemaType, UpdateSchemaType]):
    def __init__(self, model: Type[ModelType]):
        self.model = model
    def get(self, db: Session, id: Any) -> Optional[ModelType]:
        return db.query(self.model).filter(self.model.id == id).first()
    def get_multi(
        self, db: Session, *, skip: int = 0, limit: int = 100
    ) -> List[ModelType]:
        return db.query(self.model).offset(skip).limit(limit).all()
    def create(self, db: Session, *, obj_in: CreateSchemaType) -> ModelType:
        obj_in_data = jsonable_encoder(obj_in)
        db_obj = self.model(**obj_in_data)
        db.add(db_obj)
        db.commit()
        db.refresh(db_obj)
        return db_obj
    def update(
        self,
        db: Session,
        *,
        db_obj: ModelType,
        obj_in: Union[UpdateSchemaType, Dict[str, Any]]
    ) -> ModelType:
        obj_data = jsonable_encoder(db_obj)
        if isinstance(obj_in, dict):
            update_data = obj_in
        else:
            update_data = obj_in.dict(exclude_unset=True)
        for field in obj_data:
            if field in update_data:
                setattr(db_obj, field, update_data[field])
        db.add(db_obj)
        db.commit()
        db.refresh(db_obj)
        return db_obj
    def remove(self, db: Session, *, id: int) -> ModelType:
        obj = db.query(self.model).get(id)
        db.delete(obj)
        db.commit()
        return obj
--- a/app/services/class_service.py
+++ b/app/services/class_service.py
@ -0,0 +1,14 @@
 from typing import List
 from sqlalchemy.orm import Session
 from app.models.class_model import Class
 from app.schemas.class_schema import ClassCreate, ClassUpdate
 from app.services.base import CRUDBase
 class CRUDClass(CRUDBase[Class, ClassCreate, ClassUpdate]):
    def get_by_grade_level(self, db: Session, *, grade_level: str) -> List[Class]:
        return db.query(Class).filter(Class.grade_level == grade_level).all()
    def get_by_academic_year(self, db: Session, *, academic_year: str) -> List[Class]:
        return db.query(Class).filter(Class.academic_year == academic_year).all()
 class_service = CRUDClass(Class)
--- a/app/services/grade.py
+++ b/app/services/grade.py
@ -0,0 +1,20 @@
 from typing import List
 from sqlalchemy.orm import Session
 from app.models.grade import Grade
 from app.schemas.grade import GradeCreate, GradeUpdate
 from app.services.base import CRUDBase
 class CRUDGrade(CRUDBase[Grade, GradeCreate, GradeUpdate]):
    def get_by_student(self, db: Session, *, student_id: int) -> List[Grade]:
        return db.query(Grade).filter(Grade.student_id == student_id).all()
    def get_by_subject(self, db: Session, *, subject_id: int) -> List[Grade]:
        return db.query(Grade).filter(Grade.subject_id == subject_id).all()
    def get_by_student_and_subject(self, db: Session, *, student_id: int, subject_id: int) -> List[Grade]:
        return db.query(Grade).filter(
            Grade.student_id == student_id,
            Grade.subject_id == subject_id
        ).all()
 grade_service = CRUDGrade(Grade)
--- a/app/services/notification.py
+++ b/app/services/notification.py
@ -0,0 +1,35 @@
 from typing import List
 from sqlalchemy.orm import Session
 from app.models.notification import Notification
 from app.schemas.notification import NotificationCreate, NotificationUpdate
 from app.services.base import CRUDBase
 class CRUDNotification(CRUDBase[Notification, NotificationCreate, NotificationUpdate]):
    def create_with_recipients(self, db: Session, *, obj_in: NotificationCreate, sender_id: int) -> Notification:
        recipient_ids = obj_in.recipient_ids
        obj_in_data = obj_in.dict(exclude={"recipient_ids"})
        obj_in_data["sender_id"] = sender_id
        db_obj = Notification(**obj_in_data)
        db.add(db_obj)
        db.flush()
        for recipient_id in recipient_ids:
            db.execute(
                "INSERT INTO notification_recipients (notification_id, user_id) VALUES (?, ?)",
                (db_obj.id, recipient_id)
            )
        db.commit()
        db.refresh(db_obj)
        return db_obj
    def get_by_sender(self, db: Session, *, sender_id: int) -> List[Notification]:
        return db.query(Notification).filter(Notification.sender_id == sender_id).all()
    def get_by_recipient(self, db: Session, *, recipient_id: int) -> List[Notification]:
        return db.query(Notification).join(
            Notification.recipients
        ).filter_by(id=recipient_id).all()
 notification_service = CRUDNotification(Notification)
--- a/app/services/subject.py
+++ b/app/services/subject.py
@ -0,0 +1,14 @@
 from typing import List
 from sqlalchemy.orm import Session
 from app.models.subject import Subject
 from app.schemas.subject import SubjectCreate, SubjectUpdate
 from app.services.base import CRUDBase
 class CRUDSubject(CRUDBase[Subject, SubjectCreate, SubjectUpdate]):
    def get_by_class(self, db: Session, *, class_id: int) -> List[Subject]:
        return db.query(Subject).filter(Subject.class_id == class_id).all()
    def get_by_teacher(self, db: Session, *, teacher_id: int) -> List[Subject]:
        return db.query(Subject).filter(Subject.teacher_id == teacher_id).all()
 subject_service = CRUDSubject(Subject)
--- a/app/services/user.py
+++ b/app/services/user.py
@ -0,0 +1,63 @@
 from typing import Any, Dict, Optional, Union, List
 from sqlalchemy.orm import Session
 from app.core.security import get_password_hash, verify_password
 from app.models.user import User, UserRole
 from app.schemas.user import UserCreate, UserUpdate
 from app.services.base import CRUDBase
 class CRUDUser(CRUDBase[User, UserCreate, UserUpdate]):
    def get_by_email(self, db: Session, *, email: str) -> Optional[User]:
        return db.query(User).filter(User.email == email).first()
    def create(self, db: Session, *, obj_in: UserCreate) -> User:
        db_obj = User(
            email=obj_in.email,
            hashed_password=get_password_hash(obj_in.password),
            first_name=obj_in.first_name,
            last_name=obj_in.last_name,
            role=obj_in.role,
            is_active=obj_in.is_active,
            parent_id=obj_in.parent_id,
            class_id=obj_in.class_id,
        )
        db.add(db_obj)
        db.commit()
        db.refresh(db_obj)
        return db_obj
    def update(
        self, db: Session, *, db_obj: User, obj_in: Union[UserUpdate, Dict[str, Any]]
    ) -> User:
        if isinstance(obj_in, dict):
            update_data = obj_in
        else:
            update_data = obj_in.dict(exclude_unset=True)
        if "password" in update_data:
            hashed_password = get_password_hash(update_data["password"])
            del update_data["password"]
            update_data["hashed_password"] = hashed_password
        return super().update(db, db_obj=db_obj, obj_in=update_data)
    def authenticate(self, db: Session, *, email: str, password: str) -> Optional[User]:
        user = self.get_by_email(db, email=email)
        if not user:
            return None
        if not verify_password(password, user.hashed_password):
            return None
        return user
    def is_active(self, user: User) -> bool:
        return user.is_active
    def get_students(self, db: Session, *, skip: int = 0, limit: int = 100) -> List[User]:
        return db.query(User).filter(User.role == UserRole.STUDENT).offset(skip).limit(limit).all()
    def get_teachers(self, db: Session, *, skip: int = 0, limit: int = 100) -> List[User]:
        return db.query(User).filter(User.role == UserRole.TEACHER).offset(skip).limit(limit).all()
    def get_parents(self, db: Session, *, skip: int = 0, limit: int = 100) -> List[User]:
        return db.query(User).filter(User.role == UserRole.PARENT).offset(skip).limit(limit).all()
 user_service = CRUDUser(User)
--- a/main.py
+++ b/main.py
@ -0,0 +1,37 @@
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from app.api.v1.api import api_router
 from app.core.config import settings
 app = FastAPI(
    title=settings.PROJECT_NAME,
    version=settings.VERSION,
    description="School Portal API - A comprehensive school management system",
    openapi_url="/openapi.json",
    docs_url="/docs",
    redoc_url="/redoc"
 )
 app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
 )
 app.include_router(api_router, prefix="/api/v1")
@app.get("/")
 async def root():
    return {
        "title": settings.PROJECT_NAME,
        "version": settings.VERSION,
        "description": "School Portal API - A comprehensive school management system",
        "documentation": "/docs",
        "health": "/health"
    }
@app.get("/health")
 async def health_check():
    return {"status": "healthy", "service": "School Portal API"}
--- a/requirements.txt
+++ b/requirements.txt
@ -0,0 +1,9 @@
 fastapi==0.104.1
 uvicorn[standard]==0.24.0
 sqlalchemy==2.0.23
 alembic==1.12.1
 pydantic[email]==2.5.0
 python-jose[cryptography]==3.3.0
 passlib[bcrypt]==1.7.4
 python-multipart==0.0.6
 ruff==0.1.6
		`@ -0,0 +1,3 @@`
							`from sqlalchemy.ext.declarative import declarative_base`

							`Base = declarative_base()`