diff --git a/.env.example b/.env.example new file mode 100644 index 0000000..5962082 --- /dev/null +++ b/.env.example @@ -0,0 +1,2 @@ +DATABASE_URL=postgresql://devsaieh:saiehpass@localhost:5433/devtest_db +ENV=development \ No newline at end of file diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..adfc95e --- /dev/null +++ b/.gitignore @@ -0,0 +1,8 @@ +__pycache__/ +*.pyc + +docker-compose.override.yml + +pgdata/ + +alembic/versions/ diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..d3e2334 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,14 @@ +FROM python:3.12-slim + +WORKDIR /DEVTEST + +RUN apt-get update && apt-get install -y build-essential + +COPY requirements.txt . + +RUN pip install --no-cache-dir -r requirements.txt + +COPY . . +EXPOSE 8000 + +CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000", "--reload"] \ No newline at end of file diff --git a/alembic.ini b/alembic.ini new file mode 100644 index 0000000..41f54ed --- /dev/null +++ b/alembic.ini @@ -0,0 +1,116 @@ +# A generic, single database configuration. + +[alembic] +# path to migration scripts +script_location = alembic + +# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s +# Uncomment the line below if you want the files to be prepended with date and time +# see https://alembic.sqlalchemy.org/en/latest/tutorial.html#editing-the-ini-file +# for all available tokens +# file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s + +# sys.path path, will be prepended to sys.path if present. +# defaults to the current working directory. +prepend_sys_path = . + +# timezone to use when rendering the date within the migration file +# as well as the filename. +# If specified, requires the python>=3.9 or backports.zoneinfo library. +# Any required deps can installed by adding `alembic[tz]` to the pip requirements +# string value is passed to ZoneInfo() +# leave blank for localtime +# timezone = + +# max length of characters to apply to the +# "slug" field +# truncate_slug_length = 40 + +# set to 'true' to run the environment during +# the 'revision' command, regardless of autogenerate +# revision_environment = false + +# set to 'true' to allow .pyc and .pyo files without +# a source .py file to be detected as revisions in the +# versions/ directory +# sourceless = false + +# version location specification; This defaults +# to alembic/versions. When using multiple version +# directories, initial revisions must be specified with --version-path. +# The path separator used here should be the separator specified by "version_path_separator" below. +# version_locations = %(here)s/bar:%(here)s/bat:alembic/versions + +# version path separator; As mentioned above, this is the character used to split +# version_locations. The default within new alembic.ini files is "os", which uses os.pathsep. +# If this key is omitted entirely, it falls back to the legacy behavior of splitting on spaces and/or commas. +# Valid values for version_path_separator are: +# +# version_path_separator = : +# version_path_separator = ; +# version_path_separator = space +version_path_separator = os # Use os.pathsep. Default configuration used for new projects. + +# set to 'true' to search source files recursively +# in each "version_locations" directory +# new in Alembic version 1.10 +# recursive_version_locations = false + +# the output encoding used when revision files +# are written from script.py.mako +# output_encoding = utf-8 + +sqlalchemy.url = postgresql://devsaieh:saiehpass@db:5432/devtest_db + + +[post_write_hooks] +# post_write_hooks defines scripts or Python functions that are run +# on newly generated revision scripts. See the documentation for further +# detail and examples + +# format using "black" - use the console_scripts runner, against the "black" entrypoint +# hooks = black +# black.type = console_scripts +# black.entrypoint = black +# black.options = -l 79 REVISION_SCRIPT_FILENAME + +# lint with attempts to fix using "ruff" - use the exec runner, execute a binary +# hooks = ruff +# ruff.type = exec +# ruff.executable = %(here)s/.venv/bin/ruff +# ruff.options = --fix REVISION_SCRIPT_FILENAME + +# Logging configuration +[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 diff --git a/alembic/README b/alembic/README new file mode 100644 index 0000000..98e4f9c --- /dev/null +++ b/alembic/README @@ -0,0 +1 @@ +Generic single-database configuration. \ No newline at end of file diff --git a/alembic/env.py b/alembic/env.py new file mode 100644 index 0000000..f3e3922 --- /dev/null +++ b/alembic/env.py @@ -0,0 +1,81 @@ +from logging.config import fileConfig + +from sqlalchemy import engine_from_config +from sqlalchemy import pool + +from alembic import context + +# this is the Alembic Config object, which provides +# access to the values within the .ini file in use. +config = context.config + +# Interpret the config file for Python logging. +# This line sets up loggers basically. +if config.config_file_name is not None: + fileConfig(config.config_file_name) + +# add your model's MetaData object here +# for 'autogenerate' support +# from myapp import mymodel +# target_metadata = mymodel.Base.metadata +# IMPORTA Base desde donde defines tus modelos +from app.db.models import Base +target_metadata = Base.metadata + + +# other values from the config, defined by the needs of env.py, +# can be acquired: +# my_important_option = config.get_main_option("my_important_option") +# ... etc. + + +def run_migrations_offline() -> None: + """Run migrations in 'offline' mode. + + This configures the context with just a URL + and not an Engine, though an Engine is acceptable + here as well. By skipping the Engine creation + we don't even need a DBAPI to be available. + + Calls to context.execute() here emit the given string to the + script output. + + """ + 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: + """Run migrations in 'online' mode. + + In this scenario we need to create an Engine + and associate a connection with the context. + + """ + 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() diff --git a/alembic/script.py.mako b/alembic/script.py.mako new file mode 100644 index 0000000..fbc4b07 --- /dev/null +++ b/alembic/script.py.mako @@ -0,0 +1,26 @@ +"""${message} + +Revision ID: ${up_revision} +Revises: ${down_revision | comma,n} +Create Date: ${create_date} + +""" +from typing import Sequence, Union + +from alembic import op +import sqlalchemy as sa +${imports if imports else ""} + +# revision identifiers, used by Alembic. +revision: str = ${repr(up_revision)} +down_revision: Union[str, None] = ${repr(down_revision)} +branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)} +depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)} + + +def upgrade() -> None: + ${upgrades if upgrades else "pass"} + + +def downgrade() -> None: + ${downgrades if downgrades else "pass"} diff --git a/app/api/v1/endpoints/routes_demand.py b/app/api/v1/endpoints/routes_demand.py new file mode 100644 index 0000000..2d57b4e --- /dev/null +++ b/app/api/v1/endpoints/routes_demand.py @@ -0,0 +1,69 @@ +""" +Endpoints para manejar las demandas (llamadas) del ascensor. + +Incluye lógica de negocio que cierra automáticamente el último resting_period abierto +para el ascensor cuando se recibe una nueva demanda, y validaciones realistas de dominio. + +""" + +from fastapi import APIRouter, Depends, HTTPException +from sqlalchemy.orm import Session +from app.schemas.demand import DemandCreate, DemandRead +from app.db.models import Demand, RestingPeriod +from app.db.db import get_db +from datetime import datetime, timezone + +router = APIRouter() + +# Defino el rango de pisos permitido. +MIN_FLOOR = 1 +MAX_FLOOR = 12 + +@router.post("/demands/", response_model=DemandRead) +def create_demand(demand: DemandCreate, db: Session = Depends(get_db)): + """ + Registra una nueva demanda de ascensor. + - Valida que el piso esté en rango permitido. + - Cierra el último resting_period abierto (sin resting_end) para el ascensor, si existe. + """ + if demand.destination_floor < MIN_FLOOR or demand.destination_floor > MAX_FLOOR: + raise HTTPException( + status_code=400, + detail=f"El piso destino debe estar entre {MIN_FLOOR} y {MAX_FLOOR}." + ) + if demand.floor < MIN_FLOOR or demand.floor > MAX_FLOOR: + raise HTTPException( + status_code=400, + detail=f"El piso debe estar entre {MIN_FLOOR} y {MAX_FLOOR}." + ) + + # Al registrar una demanda, cerramos automáticamente el resting actual (idle) si existe. + last_resting = db.query(RestingPeriod).filter( + RestingPeriod.elevator_id == demand.elevator_id, + RestingPeriod.resting_end.is_(None) + ).order_by(RestingPeriod.resting_start.desc()).first() + + if last_resting: + # Usamos el mismo timestamp de la demanda para cerrar el periodo idle. + last_resting.resting_end = demand.timestamp_called or datetime.now(timezone.utc) + db.add(last_resting) + + db_demand = Demand( + elevator_id=demand.elevator_id, + floor=demand.floor, + destination_floor=demand.destination_floor, + timestamp_called=demand.timestamp_called or datetime.now(timezone.utc) + ) + + db.add(db_demand) + db.commit() + db.refresh(db_demand) + return db_demand + +@router.get("/demands/", response_model=list[DemandRead]) +def list_demands(db: Session = Depends(get_db)): + """ + Lista todas las demandas registradas. + Pensado para debug y análisis histórico. + """ + return db.query(Demand).all() diff --git a/app/api/v1/endpoints/routes_model.py b/app/api/v1/endpoints/routes_model.py new file mode 100644 index 0000000..47600f8 --- /dev/null +++ b/app/api/v1/endpoints/routes_model.py @@ -0,0 +1,27 @@ +from fastapi import APIRouter, HTTPException +from app.schemas.model_input import RestingFloorRequest +import joblib +import numpy as np +import os + +router = APIRouter() + +MODEL_PATH = os.path.join(os.path.dirname(__file__), "../../../ml/resting_floor_model.joblib") +model = joblib.load(MODEL_PATH) + +@router.post("/predict_resting_floor/") +def predict_resting_floor(request: RestingFloorRequest): + try: + features = [ + request.hour, + request.weekday, + request.demand_count, + request.avg_floor, + request.most_common_floor, + request.avg_direction, + request.peak_hours + ] + pred = model.predict([features])[0] + return {"best_resting_floor": int(pred)} + except Exception as e: + raise HTTPException(status_code=400, detail=str(e)) diff --git a/app/api/v1/endpoints/routes_resting.py b/app/api/v1/endpoints/routes_resting.py new file mode 100644 index 0000000..793c2c9 --- /dev/null +++ b/app/api/v1/endpoints/routes_resting.py @@ -0,0 +1,62 @@ +""" +Endpoints para registrar periodos de descanso (idle) del ascensor. + +Incluye validaciones realistas de dominio: +- El piso debe estar dentro del rango permitido. +- El periodo de descanso no puede finalizar antes de iniciar. + +""" + +from fastapi import APIRouter, Depends, HTTPException +from sqlalchemy.orm import Session +from app.schemas.resting_period import RestingPeriodCreate, RestingPeriodRead +from app.db.models import RestingPeriod +from app.db.db import get_db +from datetime import datetime, timezone + +router = APIRouter() + +# Rango de pisos permitido para este edificio (igual que en demandas). +MIN_FLOOR = 1 +MAX_FLOOR = 12 + +@router.post("/resting_periods/", response_model=RestingPeriodRead) +def create_resting_period(period: RestingPeriodCreate, db: Session = Depends(get_db)): + """ + Registra un periodo de descanso del ascensor. + - Valida rango de piso. + - Valida coherencia temporal (resting_end >= resting_start). + """ + if period.floor < MIN_FLOOR or period.floor > MAX_FLOOR: + raise HTTPException( + status_code=400, + detail=f"El piso debe estar entre {MIN_FLOOR} y {MAX_FLOOR}." + ) + # Si se ingresa resting_end, debe ser igual o posterior a resting_start (o a ahora si no se da inicio). + resting_start = period.resting_start or datetime.now(timezone.utc) + if period.resting_end and period.resting_end < resting_start: + raise HTTPException( + status_code=400, + detail="El final del periodo de descanso no puede ser anterior al inicio." + ) + db_period = RestingPeriod( + elevator_id=period.elevator_id, + floor=period.floor, + resting_start=resting_start, + resting_end=period.resting_end + ) + db.add(db_period) + db.commit() + db.refresh(db_period) + return db_period + +@router.get("/resting_periods/", response_model=list[RestingPeriodRead]) +def list_resting_periods(db: Session = Depends(get_db)): + """ + Lista todos los periodos de descanso registrados. + Esto es útil para análisis y debugging del flujo del ascensor. + """ + return db.query(RestingPeriod).all() + +# NOTA: En sistemas reales, sería interesante agregar endpoint PATCH para cerrar un periodo idle abierto cuando el ascensor recibe una demanda. +# TODO: Agregar validación para evitar superposición de periodos resting abiertos para el mismo ascensor. diff --git a/app/db/db.py b/app/db/db.py new file mode 100644 index 0000000..eecabaf --- /dev/null +++ b/app/db/db.py @@ -0,0 +1,16 @@ +from sqlalchemy import create_engine +from sqlalchemy.orm import sessionmaker +from sqlalchemy.orm import declarative_base +import os + +DATABASE_URL = os.environ.get("DATABASE_URL") or "postgresql://devsaieh:saiehpass@db:5432/devtest_db" +engine = create_engine(DATABASE_URL) +SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine) +Base = declarative_base() + +def get_db(): + db = SessionLocal() + try: + yield db + finally: + db.close() diff --git a/app/db/models.py b/app/db/models.py new file mode 100644 index 0000000..d9430a4 --- /dev/null +++ b/app/db/models.py @@ -0,0 +1,21 @@ +from sqlalchemy import Column, Integer, DateTime +from sqlalchemy.orm import declarative_base +from datetime import datetime, timezone + +Base = declarative_base() + +class Demand(Base): + __tablename__ = "demand" + id = Column(Integer, primary_key=True, index=True) + elevator_id = Column(Integer, index=True) #por ahora solo un ascensor + floor = Column(Integer, nullable=False) # Piso desde donde se llama + destination_floor = Column(Integer, nullable=False) # Piso al que quiere ir el usuario + timestamp_called = Column(DateTime, default=datetime.now(timezone.utc), index=True) + +class RestingPeriod(Base): + __tablename__ = "resting_period" + id = Column(Integer, primary_key=True, index=True) + elevator_id = Column(Integer, index=True) + floor = Column(Integer, nullable=False) + resting_start = Column(DateTime, default=datetime.now(timezone.utc), index=True) + resting_end = Column(DateTime, nullable=True, index=True) diff --git a/app/main.py b/app/main.py new file mode 100644 index 0000000..318c10c --- /dev/null +++ b/app/main.py @@ -0,0 +1,8 @@ +from fastapi import FastAPI +from app.api.v1.endpoints import routes_demand, routes_resting, routes_model + +app = FastAPI() + +app.include_router(routes_demand.router) +app.include_router(routes_resting.router) +app.include_router(routes_model.router) diff --git a/app/ml/fake_data.py b/app/ml/fake_data.py new file mode 100644 index 0000000..1f5b85c --- /dev/null +++ b/app/ml/fake_data.py @@ -0,0 +1,106 @@ +from sqlalchemy import create_engine +from sqlalchemy.orm import sessionmaker +from app.services.data_utils import create_resting_period, create_demand +from datetime import datetime, timedelta +import random +import os +import numpy as np + +DATABASE_URL = os.environ.get("DATABASE_URL") or "postgresql://devsaieh:saiehpass@localhost:5433/devtest_db" +engine = create_engine(DATABASE_URL) +Session = sessionmaker(bind=engine) + +MIN_FLOOR = 1 +MAX_FLOOR = 12 + +def random_resting_floor(hour, is_weekend): + """ + En fines de semana, el ascensor descansa más tiempo en el lobby. + """ + if hour < 7 or hour > 20: + return MIN_FLOOR + if is_weekend: + return MIN_FLOOR if random.random() < 0.7 else random.choice(range(2, MAX_FLOOR)) + # Días de semana: intermedio + return random.choice(range(2, MAX_FLOOR)) + +def random_demand(hour, is_weekend): + """ + Días de semana: patrones normales. + Fines de semana: menos tráfico, más viajes entre pisos bajos. + """ + if is_weekend: + # Menos tráfico y la mayoría son entre pisos bajos. + if random.random() < 0.8: + piso_from = random.choice([MIN_FLOOR, 2, 3]) + piso_to = random.choice([MIN_FLOOR, 2, 3]) + while piso_to == piso_from: + piso_to = random.choice([MIN_FLOOR, 2, 3]) + return piso_from, piso_to + else: + piso_from = random.randint(MIN_FLOOR, MAX_FLOOR) + piso_to = random.randint(MIN_FLOOR, MAX_FLOOR) + while piso_to == piso_from: + piso_to = random.randint(MIN_FLOOR, MAX_FLOOR) + return piso_from, piso_to + + # Días de semana: patrón original + if 8 <= hour < 10: + return MIN_FLOOR, random.randint(2, MAX_FLOOR) + elif 17 <= hour < 19: + return random.randint(2, MAX_FLOOR), MIN_FLOOR + else: + piso_from = random.randint(MIN_FLOOR, MAX_FLOOR) + piso_to = random.randint(MIN_FLOOR, MAX_FLOOR) + while piso_to == piso_from: + piso_to = random.randint(MIN_FLOOR, MAX_FLOOR) + return piso_from, piso_to + +def generate_fake_data(days=7, seed=42): + """ + Genera datos artificiales para 'days' días seguidos, con fines de semana diferenciados. + """ + random.seed(seed) + np.random.seed(seed) + session = Session() + base_date = datetime.now().replace(hour=6, minute=0, second=0, microsecond=0) + for day in range(days): + curr_time = base_date + timedelta(days=day) + weekday = curr_time.weekday() + is_weekend = weekday >= 5 # sábado=5, domingo=6 + + for i in range(10, 22): # 10:00 a 21:00 + curr_hour = curr_time.replace(hour=i) + # 1. Resting period + resting_floor = random_resting_floor(i, is_weekend) + resting_start = curr_hour + resting_duration = random.randint(5, 14) if is_weekend else random.randint(2, 8) + resting_end = curr_hour + timedelta(minutes=resting_duration) + create_resting_period( + db=session, + elevator_id=1, + floor=resting_floor, + resting_start=resting_start, + resting_end=resting_end + ) + # 2. Número de demandas menor en finde + n_demands = random.randint(0, 1) if is_weekend else random.randint(1, 2) + last_time = resting_end + for _ in range(n_demands): + from_floor, to_floor = random_demand(i, is_weekend) + # Tiempo entre descansos y demanda: exponencial (más realista) + minutes = int(np.random.exponential(scale=3)) + demand_time = last_time + timedelta(minutes=max(1, minutes)) + last_time = demand_time + create_demand( + db=session, + elevator_id=1, + floor=from_floor, + destination_floor=to_floor, + timestamp_called=demand_time + ) + session.close() + print(f"Datos artificiales generados para {days} días.") + +if __name__ == "__main__": + generate_fake_data(days=31) diff --git a/app/schemas/demand.py b/app/schemas/demand.py new file mode 100644 index 0000000..66fbe79 --- /dev/null +++ b/app/schemas/demand.py @@ -0,0 +1,27 @@ +""" +Schemas para Demandas de Ascensor. + +Estos modelos representan la estructura de los datos relacionados con las llamadas (demandas) al ascensor. +Pensé en dejar elevator_id como opcional para facilitar el desarrollo, pero en caso de escalar a múltiples ascensores debería volverse obligatorio. +""" + +from pydantic import BaseModel, Field, ConfigDict +from datetime import datetime +from typing import Optional + +class DemandBase(BaseModel): + floor: int = Field(..., description="Piso donde ocurre la llamada") + destination_floor: int = Field(..., description="Piso destino del usuario") + elevator_id: Optional[int] = Field(1, description="Identificador del ascensor (por defecto 1)") + +class DemandCreate(DemandBase): + timestamp_called: Optional[datetime] = Field( + None, + description="Momento en que se registró la demanda; se autocompleta si no se envía." + ) + +class DemandRead(DemandBase): + id: int + timestamp_called: datetime + + model_config = ConfigDict(from_attributes=True) diff --git a/app/schemas/model_input.py b/app/schemas/model_input.py new file mode 100644 index 0000000..acbdea6 --- /dev/null +++ b/app/schemas/model_input.py @@ -0,0 +1,10 @@ +from pydantic import BaseModel + +class RestingFloorRequest(BaseModel): + hour: int + weekday: int + demand_count: int + avg_floor: float + most_common_floor: int + avg_direction: float + peak_hours: int diff --git a/app/schemas/resting_period.py b/app/schemas/resting_period.py new file mode 100644 index 0000000..b33316d --- /dev/null +++ b/app/schemas/resting_period.py @@ -0,0 +1,18 @@ +from pydantic import BaseModel, ConfigDict +from datetime import datetime +from typing import Optional + +class RestingPeriodBase(BaseModel): + floor: int + elevator_id: Optional[int] = 1 + +class RestingPeriodCreate(RestingPeriodBase): + resting_start: Optional[datetime] = None + resting_end: Optional[datetime] = None + +class RestingPeriodRead(RestingPeriodBase): + id: int + resting_start: datetime + resting_end: Optional[datetime] = None + + model_config = ConfigDict(from_attributes=True) diff --git a/app/services/data_utils.py b/app/services/data_utils.py new file mode 100644 index 0000000..62ad68e --- /dev/null +++ b/app/services/data_utils.py @@ -0,0 +1,36 @@ +from app.db.models import Demand, RestingPeriod +from sqlalchemy.orm import Session +from datetime import datetime +from typing import Optional + +def create_resting_period(db: Session, elevator_id: int, floor: int, resting_start: datetime, resting_end: Optional[datetime]): + """ + Crea y guarda un periodo de descanso. + Validación extra podría añadirse aquí si cambian las reglas del dominio. + """ + rp = RestingPeriod( + elevator_id=elevator_id, + floor=floor, + resting_start=resting_start, + resting_end=resting_end, + ) + db.add(rp) + db.commit() + db.refresh(rp) + return rp + +def create_demand(db: Session, elevator_id: int, destination_floor: int, floor: int, timestamp_called: datetime): + """ + Crea y guarda una demanda (llamada de ascensor). + Esta función podría ampliarse en el futuro para cerrar resting_periods automáticamente. + """ + d = Demand( + elevator_id=elevator_id, + floor=floor, + destination_floor=destination_floor, + timestamp_called=timestamp_called, + ) + db.add(d) + db.commit() + db.refresh(d) + return d diff --git a/app/tests/test_demands.py b/app/tests/test_demands.py new file mode 100644 index 0000000..4240cfc --- /dev/null +++ b/app/tests/test_demands.py @@ -0,0 +1,95 @@ +""" +Tests para el endpoint de demandas (llamadas de ascensor). + +puntos a testear para este endpoint: +-Validacion de pisos posibles +-Validacion de piso destino +-Cierre automatico del resting_period +-Que las demandas sean guardadas en sistema +""" + +from fastapi.testclient import TestClient +from app.main import app + +client = TestClient(app) + +MIN_FLOOR = 1 +MAX_FLOOR = 12 + +def test_create_demand_ok(): + """ + Prueba que se pueda crear una demanda en el piso mínimo permitido, con un destino válido. + """ + payload = { + "floor": MIN_FLOOR, + "destination_floor": MIN_FLOOR + 1 # Un destino válido distinto al origen + } + response = client.post("/demands/", json=payload) + assert response.status_code == 200 + data = response.json() + assert data["floor"] == MIN_FLOOR + assert data["destination_floor"] == MIN_FLOOR + 1 + assert "id" in data + assert "timestamp_called" in data + +def test_create_demand_out_of_range(): + """ + No debe aceptarse una demanda para un piso inexistente. + """ + payload = { + "floor": MAX_FLOOR + 1, + "destination_floor": MIN_FLOOR + } + response = client.post("/demands/", json=payload) + assert response.status_code == 400 + assert "El piso debe estar entre" in response.json()["detail"] + +def test_create_demand_negative_floor(): + """ + Caso borde: piso negativo. + """ + payload = { + "floor": -5, + "destination_floor": MIN_FLOOR + } + response = client.post("/demands/", json=payload) + assert response.status_code == 400 + +def test_create_demand_invalid_destination(): + """ + No debe aceptarse una demanda para un destino fuera de rango. + """ + payload = { + "floor": MIN_FLOOR, + "destination_floor": MAX_FLOOR + 1 + } + response = client.post("/demands/", json=payload) + assert response.status_code == 400 + assert "piso destino" in response.json()["detail"] + +def test_list_demands(): + """ + Comprueba que las demandas se acumulen en el sistema. + """ + client.post("/demands/", json={"floor": MIN_FLOOR, "destination_floor": MIN_FLOOR + 1}) + client.post("/demands/", json={"floor": MAX_FLOOR, "destination_floor": MIN_FLOOR}) + response = client.get("/demands/") + assert response.status_code == 200 + data = response.json() + assert isinstance(data, list) + # Al menos dos demandas deben haberse registrado. + assert len(data) >= 2 + +def test_resting_is_closed_on_demand(): + """ + Prueba que al crear una demanda se cierra automáticamente el último resting abierto. + """ + # Abrimos un resting_period manualmente. + client.post("/resting_periods/", json={"floor": MIN_FLOOR}) + # Ahora creamos una demanda, que debería cerrar el resting. + response = client.post("/demands/", json={"floor": MIN_FLOOR, "destination_floor": MIN_FLOOR + 1}) + assert response.status_code == 200 + # Revisamos que el último resting_period tenga resting_end no nulo. + response = client.get("/resting_periods/") + restings = response.json() + assert restings[-1]["resting_end"] is not None diff --git a/app/tests/test_resting.py b/app/tests/test_resting.py new file mode 100644 index 0000000..314b6fe --- /dev/null +++ b/app/tests/test_resting.py @@ -0,0 +1,60 @@ +""" +Tests para endpoint de periodos de descanso (resting_periods). + +Incluye validaciones de negocio y casos raros, simulando errores comunes de usuarios o carga manual. +""" + +from fastapi.testclient import TestClient +from app.main import app + +client = TestClient(app) + +MIN_FLOOR = 1 +MAX_FLOOR = 12 + +def test_create_resting_ok(): + """ + Test simple: crear un resting_period válido en el piso más bajo. + """ + payload = {"floor": MIN_FLOOR} + response = client.post("/resting_periods/", json=payload) + assert response.status_code == 200 + data = response.json() + assert data["floor"] == MIN_FLOOR + assert "id" in data + +def test_create_resting_out_of_range(): + """ + No se debe aceptar un resting en un piso que no existe. + Suele pasar si hay un error en los sensores del sistema físico. + """ + payload = {"floor": MAX_FLOOR + 1} + response = client.post("/resting_periods/", json=payload) + assert response.status_code == 400 + +def test_create_resting_end_before_start(): + """ + Caso de error de ingreso manual: el tiempo de término no puede ser anterior al de inicio. + """ + from datetime import datetime, timedelta + start = datetime.now().isoformat() + end = (datetime.now() - timedelta(minutes=10)).isoformat() + payload = { + "floor": MIN_FLOOR, + "resting_start": start, + "resting_end": end + } + response = client.post("/resting_periods/", json=payload) + assert response.status_code == 400 + assert "no puede ser anterior" in response.json()["detail"] + +def test_list_restings(): + """ + Asegura que los periodos de descanso se almacenan correctamente y pueden ser consultados. + """ + client.post("/resting_periods/", json={"floor": MIN_FLOOR}) + response = client.get("/resting_periods/") + assert response.status_code == 200 + data = response.json() + assert isinstance(data, list) + assert len(data) >= 1 diff --git a/docker-compose.yml b/docker-compose.yml new file mode 100644 index 0000000..4dee462 --- /dev/null +++ b/docker-compose.yml @@ -0,0 +1,26 @@ +services: + db: + image: postgres:15 + environment: + POSTGRES_DB: devtest_db + POSTGRES_USER: devsaieh + POSTGRES_PASSWORD: saiehpass + ports: + - "5433:5432" + volumes: + - pgdata:/var/lib/postgresql/data + web: + build: . + command: uvicorn app.main:app --host 0.0.0.0 --port 8000 --reload + volumes: + - .:/DEVTEST + ports: + - "8000:8000" + depends_on: + - db + environment: + DATABASE_URL: postgresql://devsaieh:saiehpass@db:5432/devtest_db + ENV: development + +volumes: + pgdata: \ No newline at end of file diff --git a/makemigrations.sh b/makemigrations.sh new file mode 100755 index 0000000..8aff1e4 --- /dev/null +++ b/makemigrations.sh @@ -0,0 +1,19 @@ +set -e + +MSG=$1 + +if [ -z "$MSG" ]; then + echo "❌ Pass a migration message as an argument:" + echo "./makemigrations.sh \"mensaje de migración\"" + exit 1 +fi + +echo "Generating migration with Alembic in the container..." + +docker compose exec web alembic revision --autogenerate -m "$MSG" + +echo "Applying migration to DB..." +docker compose exec web alembic upgrade head + +echo "Migration Created!!" + diff --git a/ml/eda.ipynb b/ml/eda.ipynb new file mode 100644 index 0000000..f492c52 --- /dev/null +++ b/ml/eda.ipynb @@ -0,0 +1,1213 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "dcb41031", + "metadata": {}, + "source": [ + "# Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "id": "c1f8b06a", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "from sqlalchemy import create_engine\n", + "from datetime import datetime\n", + "import warnings\n", + "\n", + "warnings.filterwarnings(\"ignore\")\n", + "sns.set(style=\"whitegrid\")\n", + "plt.rcParams[\"figure.figsize\"] = (12, 6)\n", + "\n", + "# Conexión a la base de datos\n", + "DATABASE_URL = \"postgresql://devsaieh:saiehpass@localhost:5433/devtest_db\"\n", + "engine = create_engine(DATABASE_URL)\n" + ] + }, + { + "cell_type": "markdown", + "id": "f9b2d2c9", + "metadata": {}, + "source": [ + "# Carga de Datos" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "id": "4cfbff17", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idelevator_idfloordestination_floortimestamp_called
011432025-06-25 10:03:00
1211222025-06-25 10:12:00
231122025-06-25 11:05:00
341492025-06-25 11:07:00
45112112025-06-25 12:03:00
\n", + "
" + ], + "text/plain": [ + " id elevator_id floor destination_floor timestamp_called\n", + "0 1 1 4 3 2025-06-25 10:03:00\n", + "1 2 1 12 2 2025-06-25 10:12:00\n", + "2 3 1 1 2 2025-06-25 11:05:00\n", + "3 4 1 4 9 2025-06-25 11:07:00\n", + "4 5 1 12 11 2025-06-25 12:03:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idelevator_idfloorresting_startresting_end
01132025-06-25 10:00:002025-06-25 10:02:00
121102025-06-25 11:00:002025-06-25 11:02:00
231112025-06-25 12:00:002025-06-25 12:02:00
341102025-06-25 13:00:002025-06-25 13:05:00
45162025-06-25 14:00:002025-06-25 14:08:00
\n", + "
" + ], + "text/plain": [ + " id elevator_id floor resting_start resting_end\n", + "0 1 1 3 2025-06-25 10:00:00 2025-06-25 10:02:00\n", + "1 2 1 10 2025-06-25 11:00:00 2025-06-25 11:02:00\n", + "2 3 1 11 2025-06-25 12:00:00 2025-06-25 12:02:00\n", + "3 4 1 10 2025-06-25 13:00:00 2025-06-25 13:05:00\n", + "4 5 1 6 2025-06-25 14:00:00 2025-06-25 14:08:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "demand_df = pd.read_sql(\"SELECT * FROM demand\", engine)\n", + "resting_df = pd.read_sql(\"SELECT * FROM resting_period\", engine)\n", + "\n", + "# Conversión de fechas\n", + "demand_df[\"timestamp_called\"] = pd.to_datetime(demand_df[\"timestamp_called\"])\n", + "resting_df[\"resting_start\"] = pd.to_datetime(resting_df[\"resting_start\"])\n", + "resting_df[\"resting_end\"] = pd.to_datetime(resting_df[\"resting_end\"])\n", + "\n", + "display(demand_df.head())\n", + "display(resting_df.head())\n" + ] + }, + { + "cell_type": "markdown", + "id": "e0515f71", + "metadata": {}, + "source": [ + "# Limpieza" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "id": "76f3c9ae", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Demand nulls:\n", + " id 0\n", + "elevator_id 0\n", + "floor 0\n", + "destination_floor 0\n", + "timestamp_called 0\n", + "dtype: int64\n", + "Resting nulls:\n", + " id 0\n", + "elevator_id 0\n", + "floor 0\n", + "resting_start 0\n", + "resting_end 0\n", + "dtype: int64\n", + "\n", + "RangeIndex: 458 entries, 0 to 457\n", + "Data columns (total 5 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 id 458 non-null int64 \n", + " 1 elevator_id 458 non-null int64 \n", + " 2 floor 458 non-null int64 \n", + " 3 destination_floor 458 non-null int64 \n", + " 4 timestamp_called 458 non-null datetime64[ns]\n", + "dtypes: datetime64[ns](1), int64(4)\n", + "memory usage: 18.0 KB\n" + ] + }, + { + "data": { + "text/plain": [ + "None" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(\"Demand nulls:\\n\", demand_df.isnull().sum())\n", + "print(\"Resting nulls:\\n\", resting_df.isnull().sum())\n", + "\n", + "# Elimina duplicados\n", + "demand_df = demand_df.drop_duplicates().reset_index(drop=True)\n", + "resting_df = resting_df.drop_duplicates().reset_index(drop=True)\n", + "\n", + "# Elimina demandas fuera de rango de piso (seguridad extra)\n", + "MIN_FLOOR, MAX_FLOOR = 1, 12\n", + "demand_df = demand_df[(demand_df[\"floor\"] >= MIN_FLOOR) & (demand_df[\"floor\"] <= MAX_FLOOR)]\n", + "\n", + "demand_df = demand_df[(demand_df[\"destination_floor\"] >= MIN_FLOOR) & (demand_df[\"destination_floor\"] <= MAX_FLOOR)]\n", + "\n", + "display(demand_df.info())\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "30baba9c", + "metadata": {}, + "source": [ + "# Analisis por hora" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "id": "88ceac61", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.countplot(x=\"hour\", data=demand_df.assign(hour=lambda df: df[\"timestamp_called\"].dt.hour), palette=\"crest\")\n", + "plt.title(\"Demandas por hora\")\n", + "plt.xlabel(\"Hora del día\")\n", + "plt.ylabel(\"Número de llamadas\")\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "ac0c3b1c", + "metadata": {}, + "source": [ + "# Demanda por piso" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "id": "b6a151c8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.histplot(demand_df[\"floor\"], bins=range(MIN_FLOOR, MAX_FLOOR+2), discrete=True, color=\"salmon\")\n", + "plt.title(\"Pisos de origen de llamadas\")\n", + "plt.xlabel(\"Piso\")\n", + "plt.ylabel(\"Frecuencia\")\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "662944e1", + "metadata": {}, + "source": [ + "# Pisos de Destino" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "id": "79ed9514", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.histplot(demand_df[\"destination_floor\"], bins=range(MIN_FLOOR, MAX_FLOOR+2), discrete=True, color=\"teal\")\n", + "plt.title(\"Pisos de destino de las llamadas\")\n", + "plt.xlabel(\"Piso de destino\")\n", + "plt.ylabel(\"Frecuencia\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "e677cd1a", + "metadata": {}, + "source": [ + "# Hora vs piso origen" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "id": "74e89042", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "demand_df[\"hour\"] = demand_df[\"timestamp_called\"].dt.hour\n", + "pivot = demand_df.pivot_table(index=\"hour\", columns=\"floor\", values=\"id\", aggfunc='count', fill_value=0)\n", + "sns.heatmap(pivot, annot=True, fmt=\"d\", cmap=\"YlGnBu\")\n", + "plt.title(\"Llamadas por hora y piso\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "08ae251e", + "metadata": {}, + "source": [ + "# Duracion de descansos" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "id": "53694334", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Número de pisos\n", + "MIN_FLOOR = demand_df[\"floor\"].min()\n", + "MAX_FLOOR = demand_df[\"floor\"].max()\n", + "\n", + "# Conteo por hora y piso\n", + "calls_by_hour_floor = demand_df.groupby([\"hour\", \"floor\"]).size().unstack(fill_value=0)\n", + "calls_by_hour_floor\n", + "\n", + "# Probabilidad de que la siguiente llamada sea en cada piso para cada hora\n", + "prob_by_hour_floor = calls_by_hour_floor.div(calls_by_hour_floor.sum(axis=1), axis=0)\n", + "prob_by_hour_floor = prob_by_hour_floor.fillna(0)\n", + "prob_by_hour_floor.head(10)\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "plt.figure(figsize=(12,6))\n", + "prob_by_hour_floor.plot(kind=\"bar\", stacked=True, colormap=\"tab20\", width=1)\n", + "plt.title(\"Distribución de probabilidad de llamadas por piso para cada hora\")\n", + "plt.ylabel(\"Probabilidad\")\n", + "plt.xlabel(\"Hora del día\")\n", + "plt.legend(title=\"Piso\", bbox_to_anchor=(1,1))\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "id": "f9ed7b4d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Cálculo de duración en minutos\n", + "resting_df[\"duration_min\"] = (\n", + " resting_df[\"resting_end\"] - resting_df[\"resting_start\"]\n", + ").dt.total_seconds() / 60\n", + "\n", + "sns.histplot(resting_df[\"duration_min\"], bins=20, color=\"purple\")\n", + "plt.title(\"Duración de descansos (en minutos)\")\n", + "plt.xlabel(\"Minutos\")\n", + "plt.ylabel(\"Cantidad\")\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "dc45ea9c", + "metadata": {}, + "source": [ + "# Probabilidad de Demanda por hora y piso" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "id": "43eb1564", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
floor123456789101112
hour
100.1025640.1538460.0512820.0256410.0512820.0512820.1282050.0512820.0769230.0512820.1282050.128205
110.0833330.1388890.0555560.0833330.1666670.0833330.0555560.0555560.0833330.0833330.0555560.055556
120.1190480.0476190.1428570.0714290.0952380.0952380.0714290.0476190.0476190.0952380.0714290.095238
130.0882350.0882350.0588240.0882350.0882350.0882350.0882350.0588240.0000000.0294120.1176470.205882
140.0789470.2105260.1315790.0263160.0789470.0789470.0526320.1052630.0789470.0789470.0526320.026316
\n", + "
" + ], + "text/plain": [ + "floor 1 2 3 4 5 6 7 \\\n", + "hour \n", + "10 0.102564 0.153846 0.051282 0.025641 0.051282 0.051282 0.128205 \n", + "11 0.083333 0.138889 0.055556 0.083333 0.166667 0.083333 0.055556 \n", + "12 0.119048 0.047619 0.142857 0.071429 0.095238 0.095238 0.071429 \n", + "13 0.088235 0.088235 0.058824 0.088235 0.088235 0.088235 0.088235 \n", + "14 0.078947 0.210526 0.131579 0.026316 0.078947 0.078947 0.052632 \n", + "\n", + "floor 8 9 10 11 12 \n", + "hour \n", + "10 0.051282 0.076923 0.051282 0.128205 0.128205 \n", + "11 0.055556 0.083333 0.083333 0.055556 0.055556 \n", + "12 0.047619 0.047619 0.095238 0.071429 0.095238 \n", + "13 0.058824 0.000000 0.029412 0.117647 0.205882 \n", + "14 0.105263 0.078947 0.078947 0.052632 0.026316 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "calls_by_hour_floor = demand_df.groupby([\"hour\", \"floor\"]).size().unstack(fill_value=0)\n", + "prob_by_hour_floor = calls_by_hour_floor.div(calls_by_hour_floor.sum(axis=1), axis=0).fillna(0)\n", + "display(prob_by_hour_floor.head())\n", + "\n", + "prob_by_hour_floor.plot(kind=\"bar\", stacked=True, colormap=\"tab20\", width=1)\n", + "plt.title(\"Probabilidad de llamada por piso para cada hora\")\n", + "plt.ylabel(\"Probabilidad\")\n", + "plt.xlabel(\"Hora del día\")\n", + "plt.legend(title=\"Piso\", bbox_to_anchor=(1,1))\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "b5a91248", + "metadata": {}, + "source": [ + "# Calculo de Piso Optimo" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "id": "49865f07", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
hourbest_resting_floorexpected_distance
01073.333333
11152.777778
21263.071429
31363.382353
41452.947368
51562.722222
61642.595238
71772.973684
81882.575000
91993.176471
102072.615385
112152.450000
\n", + "
" + ], + "text/plain": [ + " hour best_resting_floor expected_distance\n", + "0 10 7 3.333333\n", + "1 11 5 2.777778\n", + "2 12 6 3.071429\n", + "3 13 6 3.382353\n", + "4 14 5 2.947368\n", + "5 15 6 2.722222\n", + "6 16 4 2.595238\n", + "7 17 7 2.973684\n", + "8 18 8 2.575000\n", + "9 19 9 3.176471\n", + "10 20 7 2.615385\n", + "11 21 5 2.450000" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def expected_distance(prob_vector, resting_floor):\n", + " # Devuelve la distancia esperada dada la probabilidad de cada piso\n", + " return np.sum([prob * abs(resting_floor - floor) for floor, prob in enumerate(prob_vector, start=MIN_FLOOR)])\n", + "\n", + "best_resting_per_hour = []\n", + "for hour in prob_by_hour_floor.index:\n", + " probs = prob_by_hour_floor.loc[hour].values\n", + " min_dist = float('inf')\n", + " best_floor = None\n", + " for resting_floor in range(MIN_FLOOR, MAX_FLOOR+1):\n", + " dist = expected_distance(probs, resting_floor)\n", + " if dist < min_dist:\n", + " min_dist = dist\n", + " best_floor = resting_floor\n", + " best_resting_per_hour.append({\"hour\": hour, \"best_resting_floor\": best_floor, \"expected_distance\": min_dist})\n", + "\n", + "resting_df_optimal = pd.DataFrame(best_resting_per_hour)\n", + "display(resting_df_optimal)" + ] + }, + { + "cell_type": "markdown", + "id": "2ddd1d16", + "metadata": {}, + "source": [ + "# Variables para ML" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "id": "47277bae", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
hourweekdaydemand_countavg_floormost_common_flooravg_directionpeak_hours
010057.2000007-0.2000000.0
110175.00000020.1428570.0
210297.00000012-0.3333330.0
3103106.50000060.4000000.0
410478.5714298-0.1428570.0
\n", + "
" + ], + "text/plain": [ + " hour weekday demand_count avg_floor most_common_floor avg_direction \\\n", + "0 10 0 5 7.200000 7 -0.200000 \n", + "1 10 1 7 5.000000 2 0.142857 \n", + "2 10 2 9 7.000000 12 -0.333333 \n", + "3 10 3 10 6.500000 6 0.400000 \n", + "4 10 4 7 8.571429 8 -0.142857 \n", + "\n", + " peak_hours \n", + "0 0.0 \n", + "1 0.0 \n", + "2 0.0 \n", + "3 0.0 \n", + "4 0.0 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Features de tiempo\n", + "demand_df[\"weekday\"] = demand_df[\"timestamp_called\"].dt.weekday\n", + "demand_df[\"is_weekend\"] = demand_df[\"weekday\"] >= 5\n", + "demand_df[\"hour\"] = demand_df[\"timestamp_called\"].dt.hour\n", + "demand_df[\"day\"] = demand_df[\"timestamp_called\"].dt.date\n", + "\n", + "# Etiqueta \"peak_hours\" (horas de alta demanda)\n", + "demand_df[\"peak_hours\"] = demand_df[\"hour\"].apply(\n", + " lambda h: 1 if (8 <= h < 10) or (17 <= h < 19) else 0\n", + ")\n", + "\n", + "# Si tienes destino\n", + "if \"destination_floor\" in demand_df.columns:\n", + " demand_df[\"direction\"] = np.sign(demand_df[\"destination_floor\"] - demand_df[\"floor\"])\n", + "else:\n", + " demand_df[\"direction\"] = np.nan\n", + "\n", + "# Features agregadas por hora/día (para ML)\n", + "features_by_hour = (\n", + " demand_df.groupby([\"hour\", \"weekday\"])\n", + " .agg(\n", + " demand_count=(\"id\", \"count\"),\n", + " avg_floor=(\"floor\", \"mean\"),\n", + " most_common_floor=(\"floor\", lambda x: x.mode().iloc[0]),\n", + " avg_direction=(\"direction\", \"mean\"),\n", + " peak_hours=(\"peak_hours\", \"mean\")\n", + " )\n", + " .reset_index()\n", + ")\n", + "display(features_by_hour.head())\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "5e98a1b5", + "metadata": {}, + "source": [ + "# Union con piso optimo" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "id": "e633a798", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
hourweekdaydemand_countavg_floormost_common_flooravg_directionpeak_hoursbest_resting_floor
010057.2000007-0.2000000.07
110175.00000020.1428570.07
210297.00000012-0.3333330.07
3103106.50000060.4000000.07
410478.5714298-0.1428570.07
\n", + "
" + ], + "text/plain": [ + " hour weekday demand_count avg_floor most_common_floor avg_direction \\\n", + "0 10 0 5 7.200000 7 -0.200000 \n", + "1 10 1 7 5.000000 2 0.142857 \n", + "2 10 2 9 7.000000 12 -0.333333 \n", + "3 10 3 10 6.500000 6 0.400000 \n", + "4 10 4 7 8.571429 8 -0.142857 \n", + "\n", + " peak_hours best_resting_floor \n", + "0 0.0 7 \n", + "1 0.0 7 \n", + "2 0.0 7 \n", + "3 0.0 7 \n", + "4 0.0 7 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "dataset_ml = pd.merge(\n", + " features_by_hour,\n", + " resting_df_optimal[[\"hour\", \"best_resting_floor\"]],\n", + " on=\"hour\",\n", + " how=\"left\"\n", + ")\n", + "display(dataset_ml.head())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "37562577", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✅ Dataset listo para entrenamiento ML: elevator_ml_dataset.csv\n" + ] + } + ], + "source": [ + "dataset_ml.to_csv(\"dataset/elevator_ml_dataset.csv\", index=False)\n", + "print(\"✅ Dataset listo para entrenamiento ML: elevator_ml_dataset.csv\")" + ] + }, + { + "cell_type": "markdown", + "id": "4ebafb14", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".env_dev", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/ml/train.ipynb b/ml/train.ipynb new file mode 100644 index 0000000..e312a1c --- /dev/null +++ b/ml/train.ipynb @@ -0,0 +1,144 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "083261c1", + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.ensemble import RandomForestClassifier\n", + "from sklearn.model_selection import train_test_split, GridSearchCV\n", + "from sklearn.metrics import classification_report, ConfusionMatrixDisplay\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "hour_features_df = pd.read_csv(\"dataset/elevator_ml_dataset.csv\")\n", + "\n", + "features = ['hour', 'weekday', 'demand_count', 'avg_floor', 'most_common_floor',\n", + " 'avg_direction', 'peak_hours']\n", + "target = \"best_resting_floor\"\n", + "\n", + "X = hour_features_df[features]\n", + "y = hour_features_df[target]\n", + "\n", + "X_train, X_test, y_train, y_test = train_test_split(\n", + " X, y, test_size=0.2, random_state=42, stratify=y\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b2673156", + "metadata": {}, + "outputs": [], + "source": [ + "param_grid = {\n", + " \"n_estimators\": [50, 100, 150],\n", + " \"max_depth\": [None, 4, 8],\n", + " \"min_samples_split\": [2, 4]\n", + "}\n", + "rf = RandomForestClassifier(random_state=42, n_jobs=-1, class_weight=\"balanced\")\n", + "grid = GridSearchCV(rf, param_grid, cv=3, scoring=\"accuracy\", verbose=1)\n", + "grid.fit(X_train, y_train)\n", + "print(\"Mejores parámetros:\", grid.best_params_)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "best_rf = grid.best_estimator_\n", + "y_pred = best_rf.predict(X_test)\n", + "\n", + "print(classification_report(y_test, y_pred))\n", + "\n", + "# Matriz de confusión\n", + "cm = ConfusionMatrixDisplay.from_estimator(\n", + " best_rf, X_test, y_test, cmap=\"Blues\", display_labels=sorted(y.unique())\n", + ")\n", + "plt.title(\"Matriz de Confusión: Piso de Descanso Óptimo\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "importances = best_rf.feature_importances_\n", + "feature_names = X.columns\n", + "indices = np.argsort(importances)[::-1]\n", + "\n", + "plt.figure(figsize=(8,5))\n", + "plt.title(\"Importancia de Features\")\n", + "plt.bar(range(len(importances)), importances[indices], align=\"center\")\n", + "plt.xticks(range(len(importances)), [feature_names[i] for i in indices], rotation=45)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f9410d8b", + "metadata": {}, + "outputs": [], + "source": [ + "import joblib\n", + "\n", + "joblib.dump(best_rf, \"/ml/models/best_resting_floor_model.joblib\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "86e16542", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3daf4068", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "59ef98b0", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7c577c62", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/pytest.ini b/pytest.ini new file mode 100644 index 0000000..22c84dc --- /dev/null +++ b/pytest.ini @@ -0,0 +1,4 @@ +[pytest] +testpaths = app/tests +python_files = test_*.py +addopts = --tb=short -p no:warnings \ No newline at end of file diff --git a/requirements-ml.txt b/requirements-ml.txt new file mode 100644 index 0000000..a57359e --- /dev/null +++ b/requirements-ml.txt @@ -0,0 +1,10 @@ +ipykernel +notebook +jupyter +pandas +matplotlib +seaborn +sqlalchemy +psycopg2-binary +joblib +scikit-learn \ No newline at end of file diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..0150a28 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,14 @@ +fastapi +uvicorn[standard] +sqlalchemy +alembic +psycopg2-binary +pydantic +pytest +pytest-cov +requests +python-dotenv +psycopg2-binary +httpx +numpy +joblb \ No newline at end of file diff --git a/runtests.sh b/runtests.sh new file mode 100755 index 0000000..ce8c692 --- /dev/null +++ b/runtests.sh @@ -0,0 +1,4 @@ +set -e +echo "🧪 Ejecutando tests en: app/tests" +docker compose exec web bash -c "PYTHONPATH=/DEVTEST pytest app/tests" +