Mira lo que tengo en user:

"""
This module contains the Role and User models for representing user roles and user data.
"""

from pydantic import BaseModel

class Role(BaseModel):
    """
    Role model representing a user role with an id and a name.
    """
    id: int
    name: str

class User(BaseModel):
    """
    User model representing a user with an id, name, email, password, and role.
    """
    id: int
    name: str
    email: str
    password: str
    role: Role

y esto es un ejemplo de como hacer las rutas y los servicios de un modelo:

# app/doctor_routes.py

"""
Module that defines the routes for managing doctors.

This module uses FastAPI to define the routes that allow
creating, reading, updating, and deleting doctors through a REST API.

Available routes:

- POST /doctors/: Creates a new doctor.
- GET /doctors/{doctor_id}: Retrieves doctor information by ID.
- PUT /doctors/{doctor_id}: Updates doctor information.
- DELETE /doctors/{doctor_id}: Deletes a doctor.

Each route uses the `DoctorService` to interact with the
business logic related to doctors.
"""

from app.services.doctor_service import DoctorService  # pylint: disable=import-error
from app.models.doctor import Doctor
from fastapi import APIRouter, HTTPException


router = APIRouter()


@router.post("/doctors/", response_model=Doctor)
def create_doctor(name: str, specialty: str) -> Doctor:
    """
    Create a new doctor.

    Args:
        name (str): The name of the doctor.
        specialty (str): The specialty of the doctor.

    Returns:
        Doctor: The created doctor.
    """
    doctor = DoctorService.create_doctor(name, specialty)
    return doctor


@router.get("/doctors/{doctor_id}", response_model=Doctor)
def get_doctor(doctor_id: int) -> Doctor:
    """
    Retrieve doctor information by ID.

    Args:
        doctor_id (int): The ID of the doctor to retrieve.

    Returns:
        Doctor: The doctor with the specified ID.

    Raises:
        HTTPException: If the doctor is not found.
    """
    doctor = DoctorService.get_doctor_by_id(doctor_id)
    if doctor:
        return doctor
    raise HTTPException(status_code=404, detail="Doctor not found")


@router.put("/doctors/{doctor_id}", response_model=Doctor)
def update_doctor(doctor_id: int, name: str = None, specialty: str = None) -> Doctor:
    """
    Update doctor information.

    Args:
        doctor_id (int): The ID of the doctor to update.
        name (str, optional): The new name of the doctor.
        specialty (str, optional): The new specialty of the doctor.

    Returns:
        Doctor: The updated doctor.

    Raises:
        HTTPException: If the doctor is not found.
    """
    doctor = DoctorService.update_doctor(doctor_id, name, specialty)
    if doctor:
        return doctor
    raise HTTPException(status_code=404, detail="Doctor not found")


@router.delete("/doctors/{doctor_id}")
def delete_doctor(doctor_id: int) -> dict:
    """
    Delete a doctor by ID.

    Args:
        doctor_id (int): The ID of the doctor to delete.

    Returns:
        dict: A confirmation message if the doctor was deleted.

    Raises:
        HTTPException: If the doctor is not found.
    """
    if DoctorService.delete_doctor(doctor_id):
        return {"message": "Doctor deleted successfully"}
    raise HTTPException(status_code=404, detail="Doctor not found")

y asi seria un servicio:

"""
Service layer for Doctor operations.

This module contains the business logic for managing doctors.
It interacts with the `DoctorModel` from the database and uses
the `Doctor` Pydantic model for data validation.
"""

from typing import Optional
from peewee import DoesNotExist  # pylint: disable=import-error
from app.database import DoctorModel  # pylint: disable=import-error
from app.models.doctor import Doctor  # pylint: disable=import-error


class DoctorService:
    """Service layer for Doctor operations."""

    @staticmethod
    def create_doctor(name: str, specialty: str) -> Doctor:
        """
        Create a new doctor.

        Args:
            name (str): The name of the doctor.
            specialty (str): The specialty of the doctor.

        Returns:
            Doctor: The created doctor instance as a Pydantic model.
        """
        doctor_instance = DoctorModel.create(name=name, specialty=specialty)
        return Doctor(
            id=doctor_instance.id,
            name=doctor_instance.name,
            specialty=doctor_instance.specialty,
        )

    @staticmethod
    def get_doctor_by_id(doctor_id: int) -> Optional[Doctor]:
        """
        Retrieve a doctor by ID.

        Args:
            doctor_id (int): The ID of the doctor to retrieve.

        Returns:
            Optional[Doctor]: The doctor instance as a Pydantic model if found, else None.
        """
        try:
            doctor_instance = DoctorModel.get_by_id(doctor_id)
            return Doctor(
                id=doctor_instance.id,
                name=doctor_instance.name,
                specialty=doctor_instance.specialty,
            )
        except DoesNotExist:
            return None

    @staticmethod
    def update_doctor(
        doctor_id: int, name: Optional[str] = None, specialty: Optional[str] = None
    ) -> Optional[Doctor]:
        """
        Update an existing doctor by ID.

        Args:
            doctor_id (int): The ID of the doctor to update.
            name (Optional[str]): The new name of the doctor.
            specialty (Optional[str]): The new specialty of the doctor.

        Returns:
            Optional[Doctor]: The updated doctor instance as a Pydantic model if successful,
            else None.

        Raises:
            ValueError: If the doctor with the given ID does not exist.
        """
        try:
            doctor_instance = DoctorModel.get_by_id(doctor_id)  # Obtain the DB model directly
            if name:
                doctor_instance.name = name
            if specialty:
                doctor_instance.specialty = specialty
            doctor_instance.save()  # Save changes to the database

            return Doctor(
                id=doctor_instance.id,
                name=doctor_instance.name,
                specialty=doctor_instance.specialty,
            )
        except DoesNotExist:
            return None

    @staticmethod
    def delete_doctor(doctor_id: int) -> bool:
        """
        Delete a doctor by ID.

        Args:
            doctor_id (int): The ID of the doctor to delete.

        Returns:
            bool: True if the doctor was deleted, else False.
        """
        try:
            doctor_instance = DoctorModel.get_by_id(doctor_id)
            doctor_instance.delete_instance()
            return True
        except DoesNotExist:
            return False

como quedaria mis rutas y servicios para user?

necesito hacer un crud y aparte, en los roles, está solo: ADMINISTRADOR Y MIEMBRO