geo-activity-playground 0.22.0__py3-none-any.whl → 0.24.0__py3-none-any.whl

geo_activity_playground/webui/app.py

@@ -1,204 +1,28 @@
-import urllib
+import json
+import pathlib
+import secrets
 
 from flask import Flask
 from flask import redirect
 from flask import render_template
 from flask import request
-from flask import Response
 
-from .locations_controller import LocationsController
+from ..core.activities import ActivityRepository
+from ..explorer.tile_visits import TileVisitAccessor
+from .activity.blueprint import make_activity_blueprint
+from .calendar.blueprint import make_calendar_blueprint
+from .eddington.blueprint import make_eddington_blueprint
+from .entry_controller import EntryController
+from .equipment.blueprint import make_equipment_blueprint
+from .explorer.blueprint import make_explorer_blueprint
+from .heatmap.blueprint import make_heatmap_blueprint
 from .search_controller import SearchController
-from geo_activity_playground.core.activities import ActivityRepository
-from geo_activity_playground.explorer.tile_visits import TileVisitAccessor
-from geo_activity_playground.webui.activity_controller import ActivityController
-from geo_activity_playground.webui.calendar_controller import CalendarController
-from geo_activity_playground.webui.config_controller import ConfigController
-from geo_activity_playground.webui.eddington_controller import EddingtonController
-from geo_activity_playground.webui.entry_controller import EntryController
-from geo_activity_playground.webui.equipment_controller import EquipmentController
-from geo_activity_playground.webui.explorer_controller import ExplorerController
-from geo_activity_playground.webui.heatmap_controller import HeatmapController
-from geo_activity_playground.webui.search_controller import SearchController
-from geo_activity_playground.webui.square_planner_controller import (
-    SquarePlannerController,
-)
-from geo_activity_playground.webui.strava_controller import StravaController
-from geo_activity_playground.webui.summary_controller import SummaryController
-from geo_activity_playground.webui.tile_controller import (
-    TileController,
-)
-from geo_activity_playground.webui.upload_controller import UploadController
-
-
-def route_activity(app: Flask, repository: ActivityRepository) -> None:
-    activity_controller = ActivityController(repository)
-
-    @app.route("/activity/all")
-    def activity_all():
-        return render_template(
-            "activity-lines.html.j2", **activity_controller.render_all()
-        )
-
-    @app.route("/activity/<id>")
-    def activity(id: str):
-        return render_template(
-            "activity.html.j2", **activity_controller.render_activity(int(id))
-        )
-
-    @app.route("/activity/<id>/sharepic.png")
-    def activity_sharepic(id: str):
-        return Response(
-            activity_controller.render_sharepic(int(id)),
-            mimetype="image/png",
-        )
-
-    @app.route("/activity/day/<year>/<month>/<day>")
-    def activity_day(year: str, month: str, day: str):
-        return render_template(
-            "activity-day.html.j2",
-            **activity_controller.render_day(int(year), int(month), int(day))
-        )
-
-    @app.route("/activity/name/<name>")
-    def activity_name(name: str):
-        return render_template(
-            "activity-name.html.j2",
-            **activity_controller.render_name(urllib.parse.unquote(name))
-        )
-
-
-def route_calendar(app: Flask, repository: ActivityRepository) -> None:
-    calendar_controller = CalendarController(repository)
-
-    @app.route("/calendar")
-    def calendar():
-        return render_template(
-            "calendar.html.j2", **calendar_controller.render_overview()
-        )
-
-    @app.route("/calendar/<year>/<month>")
-    def calendar_month(year: str, month: str):
-        return render_template(
-            "calendar-month.html.j2",
-            **calendar_controller.render_month(int(year), int(month))
-        )
-
-
-def route_config(app: Flask, repository: ActivityRepository) -> None:
-    config_controller = ConfigController(repository)
-
-    @app.route("/config")
-    def config_index():
-        return render_template("config.html.j2", **config_controller.action_index())
-
-    @app.route("/config/save", methods=["POST"])
-    def config_save():
-        form_input = request.form
-        return render_template(
-            "config.html.j2", **config_controller.action_save(form_input)
-        )
-
-
-def route_eddington(app: Flask, repository: ActivityRepository) -> None:
-    eddington_controller = EddingtonController(repository)
-
-    @app.route("/eddington")
-    def eddington():
-        return render_template("eddington.html.j2", **eddington_controller.render())
-
-
-def route_equipment(app: Flask, repository: ActivityRepository) -> None:
-    equipment_controller = EquipmentController(repository)
-
-    @app.route("/equipment")
-    def equipment():
-        return render_template("equipment.html.j2", **equipment_controller.render())
-
-
-def route_explorer(
-    app: Flask, repository: ActivityRepository, tile_visit_accessor: TileVisitAccessor
-) -> None:
-    explorer_controller = ExplorerController(repository, tile_visit_accessor)
-
-    @app.route("/explorer/<zoom>")
-    def explorer(zoom: str):
-        return render_template(
-            "explorer.html.j2", **explorer_controller.render(int(zoom))
-        )
-
-    @app.route("/explorer/<zoom>/<north>/<east>/<south>/<west>/explored.<suffix>")
-    def explorer_download(
-        zoom: str, north: str, east: str, south: str, west: str, suffix: str
-    ):
-        mimetypes = {"geojson": "application/json", "gpx": "application/xml"}
-        return Response(
-            explorer_controller.export_explored_tiles(
-                int(zoom),
-                float(north),
-                float(east),
-                float(south),
-                float(west),
-                suffix,
-            ),
-            mimetype=mimetypes[suffix],
-            headers={"Content-disposition": "attachment"},
-        )
-
-    @app.route("/explorer/<zoom>/<north>/<east>/<south>/<west>/missing.<suffix>")
-    def explorer_missing(
-        zoom: str, north: str, east: str, south: str, west: str, suffix: str
-    ):
-        mimetypes = {"geojson": "application/json", "gpx": "application/xml"}
-        return Response(
-            explorer_controller.export_missing_tiles(
-                int(zoom),
-                float(north),
-                float(east),
-                float(south),
-                float(west),
-                suffix,
-            ),
-            mimetype=mimetypes[suffix],
-            headers={"Content-disposition": "attachment"},
-        )
-
-
-def route_heatmap(
-    app: Flask, repository: ActivityRepository, tile_visit_accessor: TileVisitAccessor
-) -> None:
-    heatmap_controller = HeatmapController(repository, tile_visit_accessor)
-
-    @app.route("/heatmap")
-    def heatmap():
-        return render_template("heatmap.html.j2", **heatmap_controller.render())
-
-    @app.route("/heatmap/tile/<z>/<x>/<y>.png")
-    def heatmap_tile(x: str, y: str, z: str):
-        return Response(
-            heatmap_controller.render_tile(int(x), int(y), int(z)),
-            mimetype="image/png",
-        )
-
-    @app.route("/heatmap/download/<north>/<east>/<south>/<west>")
-    def heatmap_download(north: str, east: str, south: str, west: str):
-        return Response(
-            heatmap_controller.download_heatmap(
-                float(north),
-                float(east),
-                float(south),
-                float(west),
-            ),
-            mimetype="image/png",
-            headers={"Content-disposition": 'attachment; filename="heatmap.png"'},
-        )
-
-
-def route_locations(app: Flask, repository: ActivityRepository) -> None:
-    controller = LocationsController(repository)
-
-    @app.route("/locations")
-    def locations_index():
-        return render_template("locations.html.j2", **controller.render_index())
+from .square_planner.blueprint import make_square_planner_blueprint
+from .strava_controller import StravaController
+from .summary.blueprint import make_summary_blueprint
+from .tile.blueprint import make_tile_blueprint
+from .upload.blueprint import make_upload_blueprint
+from geo_activity_playground.core.privacy_zones import PrivacyZone
 
 
 def route_search(app: Flask, repository: ActivityRepository) -> None:
@@ -213,40 +37,12 @@ def route_search(app: Flask, repository: ActivityRepository) -> None:
         )
 
 
-def route_square_planner(
-    app: Flask, repository: ActivityRepository, tile_visit_accessor: TileVisitAccessor
-) -> None:
-    controller = SquarePlannerController(repository, tile_visit_accessor)
-
-    @app.route("/square-planner/<zoom>/<x>/<y>/<size>")
-    def square_planner_planner(zoom, x, y, size):
-        return render_template(
-            "square-planner.html.j2",
-            **controller.action_planner(int(zoom), int(x), int(y), int(size))
-        )
-
-    @app.route("/square-planner/<zoom>/<x>/<y>/<size>/missing.<suffix>")
-    def square_planner_missing(zoom, x, y, size, suffix: str):
-        mimetypes = {"geojson": "application/json", "gpx": "application/xml"}
-        return Response(
-            controller.export_missing_tiles(
-                int(zoom),
-                int(x),
-                int(y),
-                int(size),
-                suffix,
-            ),
-            mimetype=mimetypes[suffix],
-            headers={"Content-disposition": "attachment"},
-        )
-
-
 def route_start(app: Flask, repository: ActivityRepository) -> None:
     entry_controller = EntryController(repository)
 
     @app.route("/")
     def index():
-        return render_template("index.html.j2", **entry_controller.render())
+        return render_template("home.html.j2", **entry_controller.render())
 
 
 def route_strava(app: Flask, host: str, port: int) -> None:
@@ -280,52 +76,16 @@ def route_strava(app: Flask, host: str, port: int) -> None:
         )
 
 
-def route_summary(app: Flask, repository: ActivityRepository) -> None:
-    summary_controller = SummaryController(repository)
-
-    @app.route("/summary")
-    def summary_statistics():
-        return render_template("summary.html.j2", **summary_controller.render())
-
-
-def route_tiles(app: Flask, repository: ActivityRepository) -> None:
-    tile_controller = TileController()
-
-    @app.route("/tile/color/<z>/<x>/<y>.png")
-    def tile_color(x: str, y: str, z: str):
-        return Response(
-            tile_controller.render_color(int(x), int(y), int(z)), mimetype="image/png"
-        )
-
-    @app.route("/tile/grayscale/<z>/<x>/<y>.png")
-    def tile_grayscale(x: str, y: str, z: str):
-        return Response(
-            tile_controller.render_grayscale(int(x), int(y), int(z)),
-            mimetype="image/png",
-        )
-
-    @app.route("/tile/pastel/<z>/<x>/<y>.png")
-    def tile_pastel(x: str, y: str, z: str):
-        return Response(
-            tile_controller.render_pastel(int(x), int(y), int(z)), mimetype="image/png"
-        )
-
-
-def route_upload(
-    app: Flask,
-    repository: ActivityRepository,
-    tile_visit_accessor: TileVisitAccessor,
-    config: dict,
-):
-    upload_controller = UploadController(repository, tile_visit_accessor, config)
-
-    @app.route("/upload")
-    def form():
-        return render_template("upload.html.j2", **upload_controller.render_form())
-
-    @app.route("/upload/receive", methods=["POST"])
-    def receive():
-        return upload_controller.receive()
+def get_secret_key():
+    secret_file = pathlib.Path("Cache/flask-secret.json")
+    if secret_file.exists():
+        with open(secret_file) as f:
+            secret = json.load(f)
+    else:
+        secret = secrets.token_hex()
+        with open(secret_file, "w") as f:
+            json.dump(secret, f)
+    return secret
 
 
 def webui_main(
@@ -337,22 +97,49 @@ def webui_main(
 ) -> None:
     app = Flask(__name__)
 
-    route_activity(app, repository)
-    route_calendar(app, repository)
-    route_config(app, repository)
-    route_eddington(app, repository)
-    route_equipment(app, repository)
-    route_explorer(app, repository, tile_visit_accessor)
-    route_heatmap(app, repository, tile_visit_accessor)
-    route_locations(app, repository)
     route_search(app, repository)
-    route_square_planner(app, repository, tile_visit_accessor)
     route_start(app, repository)
     route_strava(app, host, port)
-    route_summary(app, repository)
-    route_tiles(app, repository)
-    route_upload(app, repository, tile_visit_accessor, config)
 
     app.config["UPLOAD_FOLDER"] = "Activities"
+    app.secret_key = get_secret_key()
+
+    app.register_blueprint(
+        make_activity_blueprint(
+            repository,
+            tile_visit_accessor,
+            [
+                PrivacyZone(points)
+                for points in config.get("privacy_zones", {}).values()
+            ],
+        ),
+        url_prefix="/activity",
+    )
+    app.register_blueprint(make_calendar_blueprint(repository), url_prefix="/calendar")
+    app.register_blueprint(
+        make_eddington_blueprint(repository), url_prefix="/eddington"
+    )
+    app.register_blueprint(
+        make_equipment_blueprint(repository), url_prefix="/equipment"
+    )
+    app.register_blueprint(
+        make_explorer_blueprint(repository, tile_visit_accessor), url_prefix="/explorer"
+    )
+    app.register_blueprint(
+        make_heatmap_blueprint(repository, tile_visit_accessor), url_prefix="/heatmap"
+    )
+    app.register_blueprint(
+        make_square_planner_blueprint(repository, tile_visit_accessor),
+        url_prefix="/square-planner",
+    )
+    app.register_blueprint(
+        make_summary_blueprint(repository),
+        url_prefix="/summary",
+    )
+    app.register_blueprint(make_tile_blueprint(), url_prefix="/tile")
+    app.register_blueprint(
+        make_upload_blueprint(repository, tile_visit_accessor, config),
+        url_prefix="/upload",
+    )
 
     app.run(host=host, port=port)

geo_activity_playground/webui/calendar/blueprint.py

@@ -0,0 +1,26 @@
+from flask import Blueprint
+from flask import render_template
+
+from ...core.activities import ActivityRepository
+from .controller import CalendarController
+
+
+def make_calendar_blueprint(repository: ActivityRepository) -> Blueprint:
+    blueprint = Blueprint("calendar", __name__, template_folder="templates")
+
+    calendar_controller = CalendarController(repository)
+
+    @blueprint.route("/")
+    def index():
+        return render_template(
+            "calendar/index.html.j2", **calendar_controller.render_overview()
+        )
+
+    @blueprint.route("/<year>/<month>")
+    def month(year: str, month: str):
+        return render_template(
+            "calendar/month.html.j2",
+            **calendar_controller.render_month(int(year), int(month))
+        )
+
+    return blueprint

geo_activity_playground/webui/{calendar_controller.py → calendar/controller.py}

@@ -1,7 +1,7 @@
 import collections
 import datetime
 
-from geo_activity_playground.core.activities import ActivityRepository
+from ...core.activities import ActivityRepository
 
 
 class CalendarController:
@@ -14,9 +14,9 @@ class CalendarController:
         meta["year"] = meta["start"].dt.year
         meta["month"] = meta["start"].dt.month
 
-        monthly_distance = meta.groupby(["year", "month"]).apply(
-            lambda group: sum(group["distance_km"])
-        )
+        monthly_distance = meta.groupby(
+            ["year", "month"],
+        ).apply(lambda group: sum(group["distance_km"]), include_groups=False)
         monthly_distance.name = "total_distance_km"
         monthly_pivot = (
             monthly_distance.reset_index()
@@ -25,7 +25,7 @@ class CalendarController:
         )
 
         yearly_distance = meta.groupby(["year"]).apply(
-            lambda group: sum(group["distance_km"])
+            lambda group: sum(group["distance_km"]), include_groups=False
         )
         yearly_distance.name = "total_distance_km"
         yearly_distances = {

geo_activity_playground/webui/{templates/calendar.html.j2 → calendar/templates/calendar/index.html.j2}

@@ -21,13 +21,14 @@
             </thead>
             <tbody>
                 {% for year, month_data in monthly_distances.items() %}
+                {% set year_int = year|round(0)|int %}
                 <tr>
-                    <td>{{ year }}</td>
+                    <td>{{ year_int }}</td>
                     {% for month in range(1, 13) %}
                     <td align="right">
                         {% set distance = month_data[month] %}
                         {% if distance %}
-                        <a href="/calendar/{{ year }}/{{ month }}">{{ distance|int() }} km</a>
+                        <a href="{{ url_for(".month", year=year_int, month=month) }}">{{ distance|int() }} km</a>
                         {% else %}
                         0 km
                         {% endif %}

geo_activity_playground/webui/{templates/calendar-month.html.j2 → calendar/templates/calendar/month.html.j2}

@@ -29,7 +29,7 @@
                     {% for day in range(1, 8) %}
                     <td>
                         {% if weeks[week][day] %}
-                        <a href="/activity/day/{{ year }}/{{ month }}/{{ day_of_month[week][day] }}"><b>{{
+                        <a href="{{ url_for('activity.day', year=year, month=month, day=day_of_month[week][day]) }}"><b>{{
                                 day_of_month[week][day] }}.</b></a>
                         {% elif day_of_month[week][day] %}
                         <b>{{ day_of_month[week][day] }}.</b>
@@ -38,7 +38,7 @@
                         {% if weeks[week][day] %}
                         <ul>
                             {% for activity in weeks[week][day] %}
-                            <li><a href="/activity/{{ activity.id }}">{{ activity.name }}</a></li>
+                            <li><a href="{{ url_for('activity.show', id=activity.id) }}">{{ activity.name }}</a></li>
                             {% endfor %}
                         </ul>
                         {% endif %}

geo_activity_playground/webui/eddington/blueprint.py

@@ -0,0 +1,19 @@
+from flask import Blueprint
+from flask import render_template
+
+from ...core.activities import ActivityRepository
+from .controller import EddingtonController
+
+
+def make_eddington_blueprint(repository: ActivityRepository) -> Blueprint:
+    blueprint = Blueprint("eddington", __name__, template_folder="templates")
+
+    eddington_controller = EddingtonController(repository)
+
+    @blueprint.route("/")
+    def index():
+        return render_template(
+            "eddington/index.html.j2", **eddington_controller.render()
+        )
+
+    return blueprint

geo_activity_playground/webui/{eddington_controller.py → eddington/controller.py}

@@ -2,7 +2,7 @@ import altair as alt
 import numpy as np
 import pandas as pd
 
-from geo_activity_playground.core.activities import ActivityRepository
+from ...core.activities import ActivityRepository
 
 
 class EddingtonController:
@@ -10,7 +10,9 @@ class EddingtonController:
         self._repository = repository
 
     def render(self) -> dict:
-        activities = self._repository.meta.copy()
+        activities = self._repository.meta.loc[
+            self._repository.meta["consider_for_achievements"]
+        ].copy()
         activities["day"] = [start.date() for start in activities["start"]]
 
         sum_per_day = activities.groupby("day").apply(
@@ -37,7 +39,7 @@ class EddingtonController:
                         width=1000,
                         title=f"Eddington Number {en}",
                     )
-                    .mark_bar()
+                    .mark_area(interpolate="step")
                     .encode(
                         alt.X(
                             "distance_km",
@@ -46,7 +48,7 @@ class EddingtonController:
                         ),
                         alt.Y(
                             "total",
-                            scale=alt.Scale(type="log"),
+                            scale=alt.Scale(domainMax=en + 10),
                             title="Days exceeding distance",
                         ),
                         [
@@ -62,8 +64,14 @@ class EddingtonController:
                     .encode(alt.X("distance_km"), alt.Y("total"))
                 )
             )
-            .interactive(bind_y=False)
+            .interactive()
             .to_json(format="vega")
         )
 
-        return {"eddington_number": en, "logarithmic_plot": logarithmic_plot}
+        return {
+            "eddington_number": en,
+            "logarithmic_plot": logarithmic_plot,
+            "eddington_table": eddington.loc[
+                (eddington["distance_km"] > en) & (eddington["distance_km"] <= en + 10)
+            ].to_dict(orient="records"),
+        }

geo_activity_playground/webui/eddington/templates/eddington/index.html.j2

@@ -0,0 +1,56 @@
+{% extends "page.html.j2" %}
+
+{% block container %}
+<h1 class="mb-3">Eddington Number</h1>
+
+<div class="row mb-3">
+    <div class="col-md-4">
+        <h2>Definition</h2>
+
+        <p>Your Eddington number is <b>{{ eddington_number }}</b>.</p>
+
+        <p>That means that on {{ eddington_number }} separate days you
+            have recorded activities exceeding {{ eddington_number }} km. Going far is one thing, going often is
+            another. But going far often is hard. Also if you increment the Eddington number, all days with less
+            distance will not count any more. It becomes increasingly hard to increment the Eddington number because you
+            don't only need to achieve a higher count, but all shorter activities don't count towards the bigger number.
+        </p>
+    </div>
+
+    <div class="col-md-8">
+        <h2>Missing days</h2>
+
+        <p>How many more days do you need to increment your Eddington number?</p>
+
+        <table class="table">
+            <thead>
+                <tr>
+                    <th>Distance / km</th>
+                    <th>Count</th>
+                    <th>Missing days</th>
+                </tr>
+            </thead>
+            <tbody>
+                {% for row in eddington_table %}
+                <tr>
+                    <td>{{ row['distance_km'] }}</td>
+                    <td>{{ row['total'] }}</td>
+                    <td>{{ row['missing'] }}</td>
+                </tr>
+                {% endfor %}
+            </tbody>
+        </table>
+    </div>
+</div>
+
+<div class="row mb-1">
+    <div class="col">
+        <h2>Plot</h2>
+
+        <p>In a graphical representation, the Eddington number is the distance where the red line intersects with the
+            blue area.</p>
+
+        {{ vega_direct("eddington-log", logarithmic_plot) }}
+    </div>
+</div>
+{% endblock %}

geo_activity_playground/webui/entry_controller.py

@@ -20,7 +20,9 @@ class EntryController:
             "latest_activities": [],
         }
 
-        for activity in itertools.islice(self._repository.iter_activities(), 15):
+        for activity in itertools.islice(
+            self._repository.iter_activities(dropna=True), 15
+        ):
             time_series = self._repository.get_time_series(activity["id"])
             result["latest_activities"].append(
                 {
@@ -33,7 +35,7 @@ class EntryController:
 
 def distance_last_30_days_meta_plot(meta: pd.DataFrame) -> str:
     before_30_days = pd.to_datetime(
-        datetime.datetime.utcnow() - datetime.timedelta(days=31), utc=True
+        datetime.datetime.now() - datetime.timedelta(days=31)
     )
     return (
         alt.Chart(

geo_activity_playground/webui/equipment/blueprint.py

@@ -0,0 +1,19 @@
+from flask import Blueprint
+from flask import render_template
+
+from ...core.activities import ActivityRepository
+from .controller import EquipmentController
+
+
+def make_equipment_blueprint(repository: ActivityRepository) -> Blueprint:
+    blueprint = Blueprint("equipment", __name__, template_folder="templates")
+
+    equipment_controller = EquipmentController(repository)
+
+    @blueprint.route("/")
+    def index():
+        return render_template(
+            "equipment/index.html.j2", **equipment_controller.render()
+        )
+
+    return blueprint