lanterno/beats - Change ULKYPF5G2QVSDEXY23FLBHEDYLO7MOSK4TAMDA75DWXWIJFCEV6AC

refacto: moves views to a separate module

Created by Ahmed Strange on January 22, 2023

ULKYPF5G2QVSDEXY23FLBHEDYLO7MOSK4TAMDA75DWXWIJFCEV6AC

Dependencies

In channels

main

Change contents

Deletion in src/server.py at line 1 [5.22]
B:BD[5.22] → [6.1936:1948]
```
import http
```
Deletion in src/server.py at line 3 [5.22]
B:BD[7.4] → [8.2089:2117]
∅:D[8.2117] → [9.2:39]
B:BD[7.4] → [9.2:39]
```
from typing import Optional
from datetime import date, timedelta
```

Replacement in src/server.py at line 5 [5.22]

B:BD[10.54] → [11.49:94]

from starlette.responses import JSONResponse

[10.54]

[5.51]

from fastapi.responses import JSONResponse

Deletion in src/server.py at line 7 [5.22]

B:BD[5.52] → [12.2:78]

B:BD[12.78] → [4.3:91]

∅:D[4.91] → [13.3:77]

B:BD[14.114] → [13.3:77]

from beats.db_helpers import serialize_from_document, serialize_to_document
from beats.exceptions import ProjectWasNotStarted, TwoProjectInProgess, NoObjectMatched
from beats.domain import ProjectRepository, Project, Beat, BeatRepository

Replacement in src/server.py at line 8 [5.22]
∅:D[15.82] → [12.255:311]
∅:D[11.131] → [12.255:311]
∅:D[16.520] → [12.255:311]
B:BD[12.255] → [12.255:311]
```
from beats.validation_models import RecordTimeValidator
```
[11.131]
[5.68]
```
from beats.routers.projects import router as projects_router
from beats.routers.beats import router as beats_router
```

Insertion in src/server.py at line 22 [5.22]

[17.98]

[11.187]

app.include_router(projects_router)
app.include_router(beats_router)

Insertion in src/server.py at line 25 [5.22]
[11.188]
[11.188]

Deletion in src/server.py at line 42 [5.22]

B:BD[11.930] → [11.930:932]

∅:D[17.98] → [7.47:69]

∅:D[11.932] → [7.47:69]

B:BD[5.70] → [7.47:69]

B:BD[7.69] → [13.78:223]

∅:D[13.223] → [18.127:143]

B:BD[18.127] → [18.127:143]

∅:D[7.135] → [5.137:139]

∅:D[18.143] → [5.137:139]

∅:D[15.157] → [5.137:139]

∅:D[17.164] → [5.137:139]

∅:D[19.420] → [5.137:139]

B:BD[5.137] → [5.137:139]

B:BD[5.139] → [6.1949:2009]

∅:D[6.2009] → [19.421:465]

B:BD[7.159] → [19.421:465]

B:BD[19.465] → [6.2010:2333]

∅:D[6.2333] → [20.2:193]

B:BD[19.543] → [20.2:193]

∅:D[20.193] → [7.196:198]

∅:D[19.543] → [7.196:198]

B:BD[7.196] → [7.196:198]

B:BD[7.198] → [4.92:134]

∅:D[4.134] → [21.90:141]

B:BD[21.90] → [21.90:141]

B:BD[21.141] → [16.521:702]

∅:D[16.702] → [22.3:88]

B:BD[21.328] → [22.3:88]


@app.get("/projects")
async def list_projects(archived: bool = False):
    data = [serialize_from_document(p) for p in ProjectRepository.list({"archived": archived})]
    return data
@app.post("/projects", status_code=http.HTTPStatus.CREATED)
async def create_project(project: Project):
    project = ProjectRepository.create(project.dict(exclude_none=True))
    return serialize_from_document(project)
@app.put("/projects")
async def update_project(project: Project):
    project = ProjectRepository.update(serialize_to_document(project.dict(exclude_none=True)))
    return serialize_from_document(project)
@app.post("/projects/{project_id}/archive")
async def archive_project(project_id: str):
    ProjectRepository.update({'_id': project_id, 'archived': True})
    return {"status": "success"}
@app.get("/projects/{project_id}/today/")
async def today_time_for_project(project_id: str):
    logs = list(BeatRepository.list({"project_id": project_id}))
    today_logs = [Beat(**serialize_from_document(log)) for log in logs if Beat(**log).start.date() == date.today()]
    return {"duration": str(sum([log.duration for log in today_logs], timedelta()))}

Deletion in src/server.py at line 44 [5.22]

B:BD[21.418] → [4.135:625]

∅:D[21.418] → [7.198:240]

∅:D[4.625] → [7.198:240]

B:BD[7.198] → [7.198:240]

B:BD[7.240] → [23.57:142]

B:BD[23.142] → [15.290:368]

∅:D[15.368] → [19.667:779]

B:BD[19.667] → [19.667:779]

B:BD[19.779] → [16.703:781]

∅:D[15.450] → [19.857:870]

∅:D[16.781] → [19.857:870]

B:BD[19.857] → [19.857:870]

B:BD[19.870] → [3.3:309]

∅:D[3.309] → [16.782:847]

B:BD[19.906] → [16.782:847]

B:BD[16.847] → [3.310:404]

∅:D[3.404] → [19.1002:1017]

∅:D[15.509] → [19.1002:1017]

∅:D[16.902] → [19.1002:1017]

B:BD[19.1002] → [19.1002:1017]

∅:D[19.1017] → [7.297:299]

B:BD[7.297] → [7.297:299]

B:BD[7.299] → [4.626:772]

∅:D[15.591] → [19.1142:1216]

∅:D[4.772] → [19.1142:1216]

∅:D[16.981] → [19.1142:1216]

B:BD[19.1142] → [19.1142:1216]

B:BD[19.1216] → [4.773:807]

∅:D[4.807] → [19.1259:1339]

∅:D[16.1016] → [19.1259:1339]

B:BD[19.1259] → [19.1259:1339]

B:BD[19.1339] → [16.1017:1039]

∅:D[16.1039] → [19.1364:1412]

B:BD[19.1364] → [19.1364:1412]

B:BD[19.1412] → [23.296:341]

B:BD[23.341] → [16.1040:1101]

∅:D[15.656] → [19.1494:1509]

∅:D[16.1101] → [19.1494:1509]

B:BD[19.1494] → [19.1494:1509]

B:BD[19.1509] → [8.2118:2120]

B:BD[8.2120] → [16.1102:1206]

∅:D[16.1206] → [8.2230:2370]

B:BD[8.2230] → [8.2230:2370]

B:BD[8.2370] → [16.1207:1253]

∅:D[16.1253] → [8.2419:2479]

B:BD[8.2419] → [8.2419:2479]

B:BD[8.2479] → [16.1254:1406]

∅:D[16.1406] → [8.2643:2685]

B:BD[8.2643] → [8.2643:2685]

B:BD[8.2685] → [16.1407:1561]

∅:D[16.1561] → [8.2863:2865]

B:BD[8.2863] → [8.2863:2865]

B:BD[8.2865] → [16.1562:1682]

∅:D[16.1682] → [8.2997:3037]

B:BD[8.2997] → [8.2997:3037]

B:BD[8.3037] → [24.3:57]

B:BD[24.57] → [14.115:319]

∅:D[14.319] → [24.139:497]

B:BD[24.139] → [24.139:497]

B:BD[24.497] → [2.3:15]

@app.get("/projects/{project_id}/summary/")
async def get_project_summary(project_id: str):
    logs = list(BeatRepository.list({"project_id": project_id}))
    logs = [Beat(**serialize_from_document(log)) for log in logs]
    statistical = {}
    for log in logs:
        if not statistical.get(log.day):
            statistical[log.day] = []
        statistical[log.day].append(log.duration)
    statistical = {key: str(sum(value)) for key, value in statistical}
    return statistical
@app.post("/projects/{project_id}/start")
async def start_project_timer(project_id: str, time_validator: RecordTimeValidator):
    available_project_ids = [str(p["_id"]) for p in ProjectRepository.list()]
    if project_id not in available_project_ids:
        return {"project_id": "This project id does not exist"}
    logs = list(BeatRepository.list({"project_id": project_id, "end": None}))
    if logs:
        log = logs[0]
        log = Beat(**serialize_from_document(log))
        return JSONResponse(
            content={"error": "another beat already in progress", "beat": log.json(exclude_none=True)},
            status_code=status.HTTP_400_BAD_REQUEST
        )
        # raise ProjectAlreadyStarted
    log = Beat(project_id=project_id, start=time_validator.time)
    log = Beat(**serialize_from_document(BeatRepository.create(log.dict(exclude_none=True))))
    return log
@app.post("/projects/stop")
async def end_project_timer(time_validator: RecordTimeValidator):
    logs = list(BeatRepository.list({"end": None}))
    if not logs:
        raise ProjectWasNotStarted
    if len(logs) > 1:
        raise TwoProjectInProgess
    log = serialize_from_document(logs[0])
    logger.info(f"We got log {log}")
    log = Beat(**log)
    logger.info(f"Validated log: {log.dict()}")
    log.stop_timer(time=time_validator.time)
    BeatRepository.update(serialize_to_document(log.dict()))
    return log
@app.get("/beats")
async def list_beats(project_id: Optional[str] = None, date: Optional[date] = None):
    filters = {}
    if project_id:
        filters.update({"project_id": project_id})
    if date:
        filters.update({"date": date})
    logs = list(BeatRepository.list(filters))
    return [serialize_from_document(log) for log in logs]
@app.post("/beats", status_code=http.HTTPStatus.CREATED)
async def create_beat(log: Beat):
    log = BeatRepository.create(log.dict(exclude_none=True))
    return serialize_from_document(log)
@app.get("/beats/{beat_id}")
async def get_beat(beat_id: str):
    beat = BeatRepository.retrieve_by_id(beat_id)
    return serialize_from_document(beat)
@app.put("/beats")
async def update_beat(log: Beat):
    log = BeatRepository.update(serialize_to_document(log.dict()))
    return serialize_from_document(log)
@app.get("/heart/sounds")
async def heart_status():
    try:
        last_beat = Beat(**serialize_from_document(BeatRepository.get_last()))
    except NoObjectMatched:
        return {
            "isBeating": False,
            "project": None,
        }
    if last_beat.is_beating():
        return {
            "isBeating": True,
            "project": last_beat.project_id,
            "since": last_beat.start,
            "so_far": last_beat.duration
        }
    else:
        return {
            "isBeating": False,
            "lastBeatOn": last_beat.project_id,
            "for": last_beat.duration
        }

File addition: routers (d--x------)
[12.313]

File addition: timer.py (----------)

[0.241]

from fastapi import APIRouter
from beats.db_helpers import serialize_from_document
from beats.domain import Beat, BeatRepository
from beats.exceptions import NoObjectMatched
router = APIRouter(
    prefix="/api/timer", tags=["Timer"],
    responses={404: {"description": "Not found"}},
)
@router.get("/status")
async def heart_status():
    try:
        last_beat = Beat(**serialize_from_document(BeatRepository.get_last()))
    except NoObjectMatched:
        return {
            "isBeating": False,
            "project": None,
        }
    if last_beat.is_beating():
        return {
            "isBeating": True,
            "project": last_beat.project_id,
            "since": last_beat.start,
            "so_far": last_beat.duration
        }
    else:
        return {
            "isBeating": False,
            "lastBeatOn": last_beat.project_id,
            "for": last_beat.duration
        }

File addition: projects.py (----------)

[0.241]

import http
import logging
from datetime import date, timedelta
from fastapi import APIRouter
from starlette import status
from starlette.responses import JSONResponse
from beats.db_helpers import serialize_from_document, serialize_to_document
from beats.domain import ProjectRepository, Project, BeatRepository, Beat
from beats.exceptions import ProjectWasNotStarted, TwoProjectInProgess
from beats.validation_models import RecordTimeValidator
logger = logging.getLogger(__name__)
router = APIRouter(
    prefix="/api/projects", tags=["Projects"],
    responses={404: {"description": "Not found"}},
)
@router.get("/")
async def list_projects(archived: bool = False):
    data = [serialize_from_document(p) for p in ProjectRepository.list({"archived": archived})]
    return data
@router.post("/", status_code=http.HTTPStatus.CREATED)
async def create_project(project: Project):
    project = ProjectRepository.create(project.dict(exclude_none=True))
    return serialize_from_document(project)
@router.put("/")
async def update_project(project: Project):
    project = ProjectRepository.update(serialize_to_document(project.dict(exclude_none=True)))
    return serialize_from_document(project)
@router.post("/{project_id}/archive")
async def archive_project(project_id: str):
    ProjectRepository.update({'_id': project_id, 'archived': True})
    return {"status": "success"}
@router.get("/{project_id}/today/")
async def today_time_for_project(project_id: str):
    logs = list(BeatRepository.list({"project_id": project_id}))
    today_logs = [Beat(**serialize_from_document(log)) for log in logs if Beat(**log).start.date() == date.today()]
    return {"duration": str(sum([log.duration for log in today_logs], timedelta()))}
@router.get("/{project_id}/summary/")
async def get_project_summary(project_id: str):
    logs = list(BeatRepository.list({"project_id": project_id}))
    logs = [Beat(**serialize_from_document(log)) for log in logs]
    statistical = {}
    for log in logs:
        if not statistical.get(log.day):
            statistical[log.day] = []
        statistical[log.day].append(log.duration)
    statistical = {key: str(sum(value)) for key, value in statistical}
    return statistical
@router.post("/{project_id}/start")
async def start_project_timer(project_id: str, time_validator: RecordTimeValidator):
    available_project_ids = [str(p["_id"]) for p in ProjectRepository.list()]
    if project_id not in available_project_ids:
        return {"project_id": "This project id does not exist"}
    logs = list(BeatRepository.list({"project_id": project_id, "end": None}))
    if logs:
        log = logs[0]
        log = Beat(**serialize_from_document(log))
        return JSONResponse(
            content={"error": "another beat already in progress", "beat": log.json(exclude_none=True)},
            status_code=status.HTTP_400_BAD_REQUEST
        )
        # raise ProjectAlreadyStarted
    log = Beat(project_id=project_id, start=time_validator.time)
    log = Beat(**serialize_from_document(BeatRepository.create(log.dict(exclude_none=True))))
    return log
@router.post("/stop")
async def end_project_timer(time_validator: RecordTimeValidator):
    logs = list(BeatRepository.list({"end": None}))
    if not logs:
        raise ProjectWasNotStarted
    if len(logs) > 1:
        raise TwoProjectInProgess
    log = serialize_from_document(logs[0])
    logger.info(f"We got log {log}")
    log = Beat(**log)
    logger.info(f"Validated log: {log.dict()}")
    log.stop_timer(time=time_validator.time)
    BeatRepository.update(serialize_to_document(log.dict()))
    return log

File addition: beats.py (----------)

[0.241]

import http
from datetime import date
from typing import Optional
from fastapi import APIRouter
from beats.db_helpers import serialize_from_document, serialize_to_document
from beats.domain import Beat, BeatRepository
router = APIRouter(
    prefix="/api/beats", tags=["Beats"],
    responses={404: {"description": "Not found"}},
)
@router.post("/", status_code=http.HTTPStatus.CREATED)
async def create_beat(log: Beat):
    log = BeatRepository.create(log.dict(exclude_none=True))
    return serialize_from_document(log)
@router.get("/")
async def list_beats(project_id: Optional[str] = None, date: Optional[date] = None):
    filters = {}
    if project_id:
        filters.update({"project_id": project_id})
    if date:
        filters.update({"date": date})
    logs = list(BeatRepository.list(filters))
    return [serialize_from_document(log) for log in logs]
@router.get("/{beat_id}")
async def get_beat(beat_id: str):
    beat = BeatRepository.retrieve_by_id(beat_id)
    return serialize_from_document(beat)
@router.put("/")
async def update_beat(log: Beat):
    log = BeatRepository.update(serialize_to_document(log.dict()))
    return serialize_from_document(log)

File addition: __init__.py (----------)
[0.241]
Insertion in src/beats/domain.py at line 86 [5.294]
[25.958]
[25.958]

refacto: moves views to a separate module

Dependencies

In channels

Change contents

Deletion in src/server.py at line 1 [5.22]

Deletion in src/server.py at line 3 [5.22]

Replacement in src/server.py at line 5 [5.22]

Deletion in src/server.py at line 7 [5.22]

Replacement in src/server.py at line 8 [5.22]

Insertion in src/server.py at line 22 [5.22]

Insertion in src/server.py at line 25 [5.22]

Deletion in src/server.py at line 42 [5.22]

Deletion in src/server.py at line 44 [5.22]

File addition: routers (d--x------)

File addition: timer.py (----------)

File addition: projects.py (----------)

File addition: beats.py (----------)

File addition: init.py (----------)

Insertion in src/beats/domain.py at line 86 [5.294]

refacto: moves views to a separate module

Dependencies

In channels

Change contents

Deletion in src/server.py at line 1 [5.22]

Deletion in src/server.py at line 3 [5.22]

Replacement in src/server.py at line 5 [5.22]

Deletion in src/server.py at line 7 [5.22]

Replacement in src/server.py at line 8 [5.22]

Insertion in src/server.py at line 22 [5.22]

Insertion in src/server.py at line 25 [5.22]

Deletion in src/server.py at line 42 [5.22]

Deletion in src/server.py at line 44 [5.22]

File addition: routers (d--x------)

File addition: timer.py (----------)

File addition: projects.py (----------)

File addition: beats.py (----------)

File addition: __init__.py (----------)

Insertion in src/beats/domain.py at line 86 [5.294]

File addition: init.py (----------)