Upload 23 files

.gitignore

@@ -0,0 +1 @@
+__pycache__/

Dockerfile

@@ -0,0 +1,15 @@
+# Usa una imagen base de Python
+FROM python:3.9
+# Establece el directorio de trabajo
+WORKDIR /code
+
+# Copia los archivos necesarios al contenedor
+COPY ./requirements.txt /code/requirements.txt
+RUN pip install --no-cache-dir -r /code/requirements.txt
+
+COPY . .
+
+RUN chmod -R 777 /code
+
+# Comando para ejecutar la aplicación
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -0,0 +1,37 @@
+# uvicorn app:app --host localhost --port 7860 --reload
+from library.librerias import *
+from routers.routers import *
+
+app = FastAPI(
+    title="API de la Academia Stephen Hawking",
+    description="Esta es la API de la academia Stephen Hawking, dedicada a la preparación preuniversitaria. Aquí se pueden realizar operaciones CRUD para gestionar estudiantes, profesores, cursos y más.",
+    version="1.0.0",
+    openapi_url="/stephen-hawking-openapi.json",
+    docs_url="/stephen-hawking-docs",
+    redoc_url="/stephen-hawking-redoc",
+    contact={
+        "name": "Academia Stephen Hawking",
+        "url": "https://www.academiashawking.com",
+        "email": "contacto@academiashawking.com",
+    },
+    license_info={"name": "MIT", "url": "https://opensource.org/licenses/MIT"},
+)
+# CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# saludo
+@app.get("/", summary="Saludo", description="Saludo de la API")
+def read_root():
+    return {"message": "Bienvenido a la API de la academia Stephen Hawking"}
+
+
+# Routers
+
+app.router.include_router(api.router)

database/__init__.py

@@ -0,0 +1 @@
+from .database import SessionLocal, engine, Base

database/database.py

@@ -0,0 +1,13 @@
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+from sqlalchemy.ext.declarative import declarative_base
+
+# Configurar la conexión a la base de datos SQLite
+DATABASE_URL = "sqlite:///database/academia.db"
+engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False})
+
+# Crear una sesión local para interactuar con la base de datos
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+# Base para definir las clases de SQLAlchemy
+Base = declarative_base()

estructura_de_BD.sql

@@ -0,0 +1,52 @@
+-- Tablas no relacionadas
+CREATE TABLE Becas (
+    ID_Beca INTEGER PRIMARY KEY,
+    Nombre_Beca TEXT NOT NULL,
+    Descripcion TEXT,
+    Monto REAL
+);
+
+CREATE TABLE Estudiantes (
+    ID_Estudiante INTEGER PRIMARY KEY,
+    Nombre TEXT NOT NULL,
+    Apellido TEXT NOT NULL,
+    Fecha_Nacimiento DATE,
+    Direccion TEXT,
+    Telefono TEXT
+);
+
+CREATE TABLE Profesores (
+    ID_Profesor INTEGER PRIMARY KEY,
+    Nombre TEXT NOT NULL,
+    Apellido TEXT NOT NULL,
+    Especialidad TEXT,
+    Telefono TEXT
+);
+
+-- Tablas relacionadas
+CREATE TABLE Cursos (
+    ID_Curso INTEGER PRIMARY KEY,
+    Nombre_Curso TEXT NOT NULL,
+    Duracion TEXT,
+    ID_Profesor INTEGER,
+    FOREIGN KEY (ID_Profesor) REFERENCES Profesores(ID_Profesor)
+);
+
+CREATE TABLE Horarios (
+    ID_Horario INTEGER PRIMARY KEY,
+    ID_Curso INTEGER,
+    Dia TEXT,
+    Hora_Inicio TIME,
+    Hora_Fin TIME,
+    FOREIGN KEY (ID_Curso) REFERENCES Cursos(ID_Curso)
+);
+
+CREATE TABLE Evaluaciones (
+    ID_Evaluacion INTEGER PRIMARY KEY,
+    ID_Estudiante INTEGER,
+    ID_Curso INTEGER,
+    Fecha DATE,
+    Calificacion INTEGER,
+    FOREIGN KEY (ID_Estudiante) REFERENCES Estudiantes(ID_Estudiante),
+    FOREIGN KEY (ID_Curso) REFERENCES Cursos(ID_Curso)
+);

generar_tablas.py

@@ -0,0 +1,16 @@
+# Ejecutar la creación de las tablas en la base de datos con el archivo base.sql
+
+import sqlite3
+
+# Conexión a la base de datos
+conexion = sqlite3.connect("academia.db")
+cursor = conexion.cursor()
+
+# Ejecutar el archivo base.sql
+with open("base.sql") as archivo:
+    cursor.executescript(archivo.read())
+
+# Cerrar la conexión
+conexion.close()
+
+print("Tablas creadas")

insertar_datos.sql

@@ -0,0 +1,138 @@
+-- Insertar datos en la tabla 'Becas'
+INSERT INTO Becas (ID_Beca, Nombre_Beca, Descripcion, Monto) VALUES
+(1, 'Beca Conacyt', 'Beca para estudios de posgrado', 15000),
+(2, 'Beca Fulbright', 'Beca para estudios en Estados Unidos', 20000),
+(3, 'Beca Senescyt', 'Beca para estudios en Ecuador', 8000),
+(4, 'Beca Pronabec', 'Beca nacional para pregrado', 5000),
+(5, 'Beca DAAD', 'Beca para estudios en Alemania', 25000),
+(6, 'Beca Chevening', 'Beca para estudios en Reino Unido', 30000),
+(7, 'Beca Santander', 'Beca para intercambios internacionales', 10000),
+(8, 'Beca Erasmus+', 'Beca para estudios en Europa', 12000),
+(9, 'Beca Gates', 'Beca completa para Cambridge', 35000),
+(10, 'Beca Sor Juana Inés de la Cruz', 'Beca para mujeres en ciencia', 9500),
+(11, 'Beca Einstein', 'Beca para física teórica', 11000),
+(12, 'Beca Hawking', 'Beca para investigación espacial', 15000),
+(13, 'Beca Marie Curie', 'Beca para investigación en química', 20000),
+(14, 'Beca Tesla', 'Beca para innovación tecnológica', 18000),
+(15, 'Beca Picasso', 'Beca para artes visuales', 12000),
+(16, 'Beca Mozart', 'Beca para música clásica', 7000),
+(17, 'Beca Cervantes', 'Beca para estudios literarios', 9500),
+(18, 'Beca Confucio', 'Beca para estudios en China', 11000),
+(19, 'Beca Borges', 'Beca para literatura fantástica', 8000),
+(20, 'Beca Darwin', 'Beca para biología evolutiva', 14000);
+
+-- Insertar datos en la tabla 'Estudiantes'
+INSERT INTO Estudiantes (ID_Estudiante, Nombre, Apellido, Fecha_Nacimiento, Direccion, Telefono) VALUES
+(1, 'Juan', 'Pérez', '1990-05-14', 'Av. Siempre Viva 123', '555-1234'),
+(2, 'Ana', 'García', '1992-07-18', 'Calle Falsa 456', '555-5678'),
+(3, 'Luis', 'Morales', '1993-09-22', 'Av. Principal 789', '555-8765'),
+(4, 'Lucía', 'Fernández', '1989-11-30', 'Calle Nueva 101', '555-4567'),
+(5, 'María', 'Vásquez', '1991-03-15', 'Av. Las Palmas 234', '555-3456'),
+(6, 'Carlos', 'Jiménez', '1994-12-24', 'Calle Vieja 567', '555-2345'),
+(7, 'Sofía', 'López', '1988-08-09', 'Av. Libertad 890', '555-6789'),
+(8, 'Diego', 'Martínez', '1995-06-04', 'Calle Sol 321', '555-7890'),
+(9, 'Ana', 'Ruiz', '1992-01-17', 'Av. Luna 654', '555-8901'),
+(10, 'Oscar', 'Díaz', '1990-04-25', 'Calle Estrella 987', '555-9012'),
+(11, 'Mónica', 'Campos', '1993-02-13', 'Av. Río 345', '555-0123'),
+(12, 'Roberto', 'Sánchez', '1991-07-19', 'Calle Lago 678', '555-1235'),
+(13, 'Sandra', 'Molina', '1989-08-31', 'Av. Bosque 789', '555-2346'),
+(14, 'David', 'Ortiz', '1992-10-20', 'Calle Jardín 890', '555-3457'),
+(15, 'Carmen', 'Navarro', '1990-09-10', 'Av. Montaña 123', '555-4568'),
+(16, 'Fernando', 'González', '1994-12-15', 'Calle Océano 234', '555-5679'),
+(17, 'Gloria', 'Vega', '1991-03-03', 'Av. Desierto 345', '555-6780'),
+(18, 'Héctor', 'Álvarez', '1993-05-29', 'Calle Isla 456', '555-7891'),
+(19, 'Susana', 'Benítez', '1988-11-11', 'Av. Volcán 567', '555-8902'),
+(20, 'Ricardo', 'Montoya', '1995-01-02', 'Calle Bosque 678', '555-9013');
+
+-- Insertar datos en la tabla 'Profesores'
+INSERT INTO Profesores (ID_Profesor, Nombre, Apellido, Especialidad, Telefono) VALUES
+(1, 'Carlos', 'Santana', 'Matemáticas', '555-9876'),
+(2, 'Laura', 'Gomez', 'Literatura', '555-6543'),
+(3, 'José', 'Martínez', 'Física', '555-3210'),
+(4, 'Carmen', 'López', 'Historia', '555-4321'),
+(5, 'Lucas', 'Fernández', 'Química', '555-5432'),
+(6, 'Marta', 'García', 'Biología', '555-6542'),
+(7, 'Ana', 'Ruiz', 'Informática', '555-7653'),
+(8, 'David', 'Morales', 'Educación física', '555-8764'),
+(9, 'Sofía', 'Alvarez', 'Arte', '555-9875'),
+(10, 'Luis', 'Gómez', 'Música', '555-0987'),
+(11, 'Mónica', 'Campos', 'Psicología', '555-1098'),
+(12, 'Roberto', 'Sánchez', 'Sociología', '555-2109'),
+(13, 'Sandra', 'Molina', 'Filosofía', '555-3219'),
+(14, 'David', 'Ortiz', 'Ingeniería', '555-4328'),
+(15, 'Carmen', 'Navarro', 'Arquitectura', '555-5437'),
+(16, 'Fernando', 'González', 'Derecho', '555-6546'),
+(17, 'Gloria', 'Vega', 'Medicina', '555-7657'),
+(18, 'Héctor', 'Álvarez', 'Enfermería', '555-8768'),
+(19, 'Susana', 'Benítez', 'Nutrición', '555-9879'),
+(20, 'Ricardo', 'Montoya', 'Odontología', '555-0980');
+
+-- Continúa con las tablas relacionadas en el siguiente mensaje
+-- Insertar datos en la tabla 'Cursos'
+INSERT INTO Cursos (ID_Curso, Nombre_Curso, Duracion, ID_Profesor) VALUES
+(1, 'Cálculo', 'Semestral', 1),
+(2, 'Literatura Moderna', 'Anual', 2),
+(3, 'Mecánica Clásica', 'Semestral', 3),
+(4, 'Historia Universal', 'Anual', 4),
+(5, 'Química Orgánica', 'Semestral', 5),
+(6, 'Biología Molecular', 'Anual', 6),
+(7, 'Programación Avanzada', 'Semestral', 7),
+(8, 'Educación Física', 'Anual', 8),
+(9, 'Técnicas de Pintura', 'Semestral', 9),
+(10, 'Teoría Musical', 'Anual', 10),
+(11, 'Psicología del Aprendizaje', 'Semestral', 11),
+(12, 'Sociología Urbana', 'Anual', 12),
+(13, 'Ética y Filosofía', 'Semestral', 13),
+(14, 'Ingeniería de Sistemas', 'Anual', 14),
+(15, 'Diseño Arquitectónico', 'Semestral', 15),
+(16, 'Derecho Internacional', 'Anual', 16),
+(17, 'Medicina General', 'Semestral', 17),
+(18, 'Cuidados de Enfermería', 'Anual', 18),
+(19, 'Dietética y Nutrición', 'Semestral', 19),
+(20, 'Odontología Preventiva', 'Anual', 20);
+
+-- Insertar datos en la tabla 'Horarios'
+INSERT INTO Horarios (ID_Horario, ID_Curso, Dia, Hora_Inicio, Hora_Fin) VALUES
+(1, 1, 'Lunes', '08:00', '10:00'),
+(2, 1, 'Miércoles', '08:00', '10:00'),
+(3, 2, 'Martes', '10:00', '12:00'),
+(4, 2, 'Jueves', '10:00', '12:00'),
+(5, 3, 'Lunes', '10:00', '12:00'),
+(6, 3, 'Miércoles', '10:00', '12:00'),
+(7, 4, 'Martes', '08:00', '10:00'),
+(8, 4, 'Jueves', '08:00', '10:00'),
+(9, 5, 'Lunes', '12:00', '14:00'),
+(10, 5, 'Miércoles', '12:00', '14:00'),
+(11, 6, 'Martes', '12:00', '14:00'),
+(12, 6, 'Jueves', '12:00', '14:00'),
+(13, 7, 'Lunes', '14:00', '16:00'),
+(14, 7, 'Miércoles', '14:00', '16:00'),
+(15, 8, 'Martes', '14:00', '16:00'),
+(16, 8, 'Jueves', '14:00', '16:00'),
+(17, 9, 'Lunes', '16:00', '18:00'),
+(18, 9, 'Miércoles', '16:00', '18:00'),
+(19, 10, 'Martes', '16:00', '18:00'),
+(20, 10, 'Jueves', '16:00', '18:00');
+
+-- Insertar datos en la tabla 'Evaluaciones'
+INSERT INTO Evaluaciones (ID_Evaluacion, ID_Estudiante, ID_Curso, Fecha, Calificacion) VALUES
+(1, 1, 1, '2023-06-15', 85),
+(2, 2, 2, '2023-06-16', 90),
+(3, 3, 3, '2023-06-17', 88),
+(4, 4, 4, '2023-06-18', 95),
+(5, 5, 5, '2023-06-19', 80),
+(6, 6, 6, '2023-06-20', 70),
+(7, 7, 7, '2023-06-21', 85),
+(8, 8, 8, '2023-06-22', 90),
+(9, 9, 9, '2023-06-23', 95),
+(10, 10, 10, '2023-06-24', 85),
+(11, 11, 11, '2023-06-25', 92),
+(12, 12, 12, '2023-06-26', 87),
+(13, 13, 13, '2023-06-27', 93),
+(14, 14, 14, '2023-06-28', 89),
+(15, 15, 15, '2023-06-29', 94),
+(16, 16, 16, '2023-06-30', 78),
+(17, 17, 17, '2023-07-01', 88),
+(18, 18, 18, '2023-07-02', 90),
+(19, 19, 19, '2023-07-03', 86),
+(20, 20, 20, '2023-07-04', 91);

library/librerias.py

@@ -0,0 +1,21 @@
+# librerias propias del lenguaje
+from datetime import datetime
+from datetime import date
+import os
+
+# librerias para la API
+from pydantic import BaseModel
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+from fastapi import APIRouter, Depends, status
+import uvicorn
+
+# importar librerias para la conexion a la base de datos
+from queue import Queue
+import sqlite3
+import threading
+
+
+# clase para la conexion a la base de datos
+from database.database import SessionLocal, engine

models/schema.py

@@ -0,0 +1,137 @@
+from pydantic import BaseModel
+from typing import Optional
+from datetime import date, time
+
+
+class BecasBase(BaseModel):
+    Nombre_Beca: str
+    Descripción: str
+    Monto: float
+
+
+class BecasCreate(BecasBase):
+    pass
+
+
+class Becas(BecasBase):
+    ID_Beca: int
+
+    class Config:
+        from_attributes = True
+
+
+class SearchBecas(BaseModel):
+    nombre_beca: str = ""
+
+
+class EstudiantesBase(BaseModel):
+    Nombre: str
+    Apellido: str
+    Fecha_Nacimiento: Optional[date] = None
+    Dirección: Optional[str] = None
+    Teléfono: Optional[str] = None
+
+
+class EstudiantesCreate(EstudiantesBase):
+    pass
+
+
+class Estudiantes(EstudiantesBase):
+    ID_Estudiante: int
+
+    class Config:
+        from_attributes = True
+
+
+class SearchEstudiantes(BaseModel):
+    nombre: str = ""
+    apellido: str = ""
+
+
+class ProfesoresBase(BaseModel):
+    Nombre: str
+    Apellido: str
+    Especialidad: str
+    Teléfono: Optional[str] = None
+
+
+class ProfesoresCreate(ProfesoresBase):
+    pass
+
+
+class Profesores(ProfesoresBase):
+    ID_Profesor: int
+
+    class Config:
+        from_attributes = True
+
+
+class SearchProfesores(BaseModel):
+    nombre: str = ""
+    apellido: str = ""
+
+
+class CursosBase(BaseModel):
+    Nombre_Curso: str
+    Duración: str
+    ID_Profesor: Optional[int] = None
+
+
+class CursosCreate(CursosBase):
+    pass
+
+
+class Cursos(CursosBase):
+    ID_Curso: int
+
+    class Config:
+        from_attributes = True
+
+
+class SearchCursos(BaseModel):
+    nombre_curso: str = ""
+
+
+class HorariosBase(BaseModel):
+    ID_Curso: int
+    Día: str
+    Hora_Inicio: time
+    Hora_Fin: time
+
+
+class HorariosCreate(HorariosBase):
+    pass
+
+
+class Horarios(HorariosBase):
+    ID_Horario: int
+
+    class Config:
+        from_attributes = True
+
+
+class SearchHorarios(BaseModel):
+    dia: str = ""
+
+
+class EvaluacionesBase(BaseModel):
+    ID_Estudiante: int
+    ID_Curso: int
+    Fecha: date
+    Calificación: int
+
+
+class EvaluacionesCreate(EvaluacionesBase):
+    pass
+
+
+class Evaluaciones(EvaluacionesBase):
+    ID_Evaluación: int
+
+    class Config:
+        from_attributes = True
+
+
+class SearchEvaluaciones(BaseModel):
+    id_estudiante: int = 0
+    id_curso: int = 0

requirements.txt

@@ -0,0 +1,2 @@
+fastapi
+uvicorn

routers/api.py

@@ -0,0 +1,194 @@
+from fastapi import APIRouter, Depends, HTTPException
+from typing import List
+from sqlalchemy.orm import Session
+from models.schema import (
+    Becas,
+    BecasCreate,
+    SearchBecas,
+    Estudiantes,
+    EstudiantesCreate,
+    SearchEstudiantes,
+    Profesores,
+    ProfesoresCreate,
+    SearchProfesores,
+    Cursos,
+    CursosCreate,
+    SearchCursos,
+    Horarios,
+    HorariosCreate,
+    SearchHorarios,
+    Evaluaciones,
+    EvaluacionesCreate,
+    SearchEvaluaciones,
+)
+from database.database import Base, SessionLocal, engine
+from models.schema import (
+    Becas as DBBecas,
+    Estudiantes as DBEstudiantes,
+    Profesores as DBProfesores,
+    Cursos as DBCursos,
+    Horarios as DBHorarios,
+    Evaluaciones as DBEvaluaciones,
+)
+
+router = APIRouter(
+    prefix="/api",
+    tags=["Academia_Stephen_Hawking_API"],
+    responses={404: {"description": "No encontrado"}},
+)
+
+# Inicializar la base de datos
+Base.metadata.create_all(bind=engine)
+
+
+# Función auxiliar para obtener una sesión de la base de datos
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+
+# Becas
+@router.get("/becas/", response_model=List[Becas])
+def get_becas(db: Session = Depends(get_db)):
+    return db.query(DBBecas).all()
+
+
+@router.post("/becas/", response_model=Becas)
+def create_beca(beca: BecasCreate, db: Session = Depends(get_db)):
+    db_beca = DBBecas(**beca.dict())
+    db.add(db_beca)
+    db.commit()
+    db.refresh(db_beca)
+    return db_beca
+
+
+@router.get("/becas/search/", response_model=List[Becas])
+def search_becas(beca: SearchBecas, db: Session = Depends(get_db)):
+    query = db.query(DBBecas)
+    if beca.nombre_beca:
+        query = query.filter(DBBecas.Nombre_Beca.contains(beca.nombre_beca))
+    return query.all()
+
+
+# Estudiantes
+@router.get("/estudiantes/", response_model=List[Estudiantes])
+def get_estudiantes(db: Session = Depends(get_db)):
+    return db.query(DBEstudiantes).all()
+
+
+@router.post("/estudiantes/", response_model=Estudiantes)
+def create_estudiante(estudiante: EstudiantesCreate, db: Session = Depends(get_db)):
+    db_estudiante = DBEstudiantes(**estudiante.dict())
+    db.add(db_estudiante)
+    db.commit()
+    db.refresh(db_estudiante)
+    return db_estudiante
+
+
+@router.get("/estudiantes/search/", response_model=List[Estudiantes])
+def search_estudiantes(estudiante: SearchEstudiantes, db: Session = Depends(get_db)):
+    query = db.query(DBEstudiantes)
+    if estudiante.nombre:
+        query = query.filter(DBEstudiantes.Nombre.contains(estudiante.nombre))
+    if estudiante.apellido:
+        query = query.filter(DBEstudiantes.Apellido.contains(estudiante.apellido))
+    return query.all()
+
+
+# Profesores
+@router.get("/profesores/", response_model=List[Profesores])
+def get_profesores(db: Session = Depends(get_db)):
+    return db.query(DBProfesores).all()
+
+
+@router.post("/profesores/", response_model=Profesores)
+def create_profesor(profesor: ProfesoresCreate, db: Session = Depends(get_db)):
+    db_profesor = DBProfesores(**profesor.dict())
+    db.add(db_profesor)
+    db.commit()
+    db.refresh(db_profesor)
+    return db_profesor
+
+
+@router.get("/profesores/search/", response_model=List[Profesores])
+def search_profesores(profesor: SearchProfesores, db: Session = Depends(get_db)):
+    query = db.query(DBProfesores)
+    if profesor.nombre:
+        query = query.filter(DBProfesores.Nombre.contains(profesor.nombre))
+    if profesor.apellido:
+        query = query.filter(DBProfesores.Apellido.contains(profesor.apellido))
+    return query.all()
+
+
+# Cursos
+@router.get("/cursos/", response_model=List[Cursos])
+def get_cursos(db: Session = Depends(get_db)):
+    return db.query(DBCursos).all()
+
+
+@router.post("/cursos/", response_model=Cursos)
+def create_curso(curso: CursosCreate, db: Session = Depends(get_db)):
+    db_curso = DBCursos(**curso.dict())
+    db.add(db_curso)
+    db.commit()
+    db.refresh(db_curso)
+    return db_curso
+
+
+@router.get("/cursos/search/", response_model=List[Cursos])
+def search_cursos(curso: SearchCursos, db: Session = Depends(get_db)):
+    query = db.query(DBCursos)
+    if curso.nombre_curso:
+        query = query.filter(DBCursos.Nombre_Curso.contains(curso.nombre_curso))
+    return query.all()
+
+
+# Horarios
+@router.get("/horarios/", response_model=List[Horarios])
+def get_horarios(db: Session = Depends(get_db)):
+    return db.query(DBHorarios).all()
+
+
+@router.post("/horarios/", response_model=Horarios)
+def create_horario(horario: HorariosCreate, db: Session = Depends(get_db)):
+    db_horario = DBHorarios(**horario.dict())
+    db.add(db_horario)
+    db.commit()
+    db.refresh(db_horario)
+    return db_horario
+
+
+@router.get("/horarios/search/", response_model=List[Horarios])
+def search_horarios(horario: SearchHorarios, db: Session = Depends(get_db)):
+    query = db.query(DBHorarios)
+    if horario.dia:
+        query = query.filter(DBHorarios.Día.contains(horario.dia))
+    return query.all()
+
+
+# Evaluaciones
+@router.get("/evaluaciones/", response_model=List[Evaluaciones])
+def get_evaluaciones(db: Session = Depends(get_db)):
+    return db.query(DBEvaluaciones).all()
+
+
+@router.post("/evaluaciones/", response_model=Evaluaciones)
+def create_evaluacion(evaluacion: EvaluacionesCreate, db: Session = Depends(get_db)):
+    db_evaluacion = DBEvaluaciones(**evaluacion.dict())
+    db.add(db_evaluacion)
+    db.commit()
+    db.refresh(db_evaluacion)
+    return db_evaluacion
+
+
+@router.get("/evaluaciones/search/", response_model=List[Evaluaciones])
+def search_evaluaciones(evaluacion: SearchEvaluaciones, db: Session = Depends(get_db)):
+    query = db.query(DBEvaluaciones)
+    if evaluacion.id_estudiante:
+        query = query.filter(DBEvaluaciones.ID_Estudiante == evaluacion.id_estudiante)
+    if evaluacion.id_curso:
+        query = query.filter(DBEvaluaciones.ID_Curso == evaluacion.id_curso)
+    return query.all()

routers/routers.py

@@ -0,0 +1 @@
+from routers import api