geo-activity-playground 0.26.2__py3-none-any.whl → 0.27.0__py3-none-any.whl

geo_activity_playground/webui/equipment/controller.py

@@ -2,12 +2,13 @@ import altair as alt
 import pandas as pd
 
 from geo_activity_playground.core.activities import ActivityRepository
-from geo_activity_playground.core.config import get_config
+from geo_activity_playground.core.config import Config
 
 
 class EquipmentController:
-    def __init__(self, repository: ActivityRepository) -> None:
+    def __init__(self, repository: ActivityRepository, config: Config) -> None:
         self._repository = repository
+        self._config = config
 
     def render(self) -> dict:
         kind_per_equipment = self._repository.meta.groupby("equipment").apply(
@@ -101,10 +102,8 @@ class EquipmentController:
                 "usages_plot_id": f"usages_plot_{hash(equipment)}",
             }
 
-        config = get_config()
-        if "offsets" in config:
-            for equipment, offset in config["offsets"].items():
-                equipment_summary.loc[equipment, "total_distance_km"] += offset
+        for equipment, offset in self._config.equipment_offsets.items():
+            equipment_summary.loc[equipment, "total_distance_km"] += offset
 
         return {
             "equipment_variables": equipment_variables,

geo_activity_playground/webui/explorer/blueprint.py

@@ -1,16 +1,23 @@
 from flask import Blueprint
+from flask import redirect
 from flask import render_template
 from flask import Response
+from flask import url_for
 
 from ...core.activities import ActivityRepository
 from ...explorer.tile_visits import TileVisitAccessor
 from .controller import ExplorerController
+from geo_activity_playground.core.config import ConfigAccessor
 
 
 def make_explorer_blueprint(
-    repository: ActivityRepository, tile_visit_accessor: TileVisitAccessor
+    repository: ActivityRepository,
+    tile_visit_accessor: TileVisitAccessor,
+    config_accessor: ConfigAccessor,
 ) -> Blueprint:
-    explorer_controller = ExplorerController(repository, tile_visit_accessor)
+    explorer_controller = ExplorerController(
+        repository, tile_visit_accessor, config_accessor
+    )
     blueprint = Blueprint("explorer", __name__, template_folder="templates")
 
     @blueprint.route("/<zoom>")
@@ -19,6 +26,11 @@ def make_explorer_blueprint(
             "explorer/index.html.j2", **explorer_controller.render(int(zoom))
         )
 
+    @blueprint.route("/enable-zoom-level/<zoom>")
+    def enable_zoom_level(zoom: str):
+        explorer_controller.enable_zoom_level(int(zoom))
+        return redirect(url_for(".map", zoom=zoom))
+
     @blueprint.route("/<zoom>/<north>/<east>/<south>/<west>/explored.<suffix>")
     def download(zoom: str, north: str, east: str, south: str, west: str, suffix: str):
         mimetypes = {"geojson": "application/json", "gpx": "application/xml"}

geo_activity_playground/webui/explorer/controller.py

@@ -7,8 +7,10 @@ import geojson
 import matplotlib
 import numpy as np
 import pandas as pd
+from flask import flash
 
 from geo_activity_playground.core.activities import ActivityRepository
+from geo_activity_playground.core.config import ConfigAccessor
 from geo_activity_playground.core.coordinates import Bounds
 from geo_activity_playground.core.tiles import compute_tile
 from geo_activity_playground.core.tiles import get_tile_upper_left_lat_lon
@@ -19,6 +21,7 @@ from geo_activity_playground.explorer.grid_file import make_explorer_tile
 from geo_activity_playground.explorer.grid_file import make_grid_file_geojson
 from geo_activity_playground.explorer.grid_file import make_grid_file_gpx
 from geo_activity_playground.explorer.grid_file import make_grid_points
+from geo_activity_playground.explorer.tile_visits import compute_tile_evolution
 from geo_activity_playground.explorer.tile_visits import TileEvolutionState
 from geo_activity_playground.explorer.tile_visits import TileVisitAccessor
 
@@ -28,12 +31,29 @@ alt.data_transformers.enable("vegafusion")
 
 class ExplorerController:
     def __init__(
-        self, repository: ActivityRepository, tile_visit_accessor: TileVisitAccessor
+        self,
+        repository: ActivityRepository,
+        tile_visit_accessor: TileVisitAccessor,
+        config_accessor: ConfigAccessor,
     ) -> None:
         self._repository = repository
         self._tile_visit_accessor = tile_visit_accessor
+        self._config_accessor = config_accessor
+
+    def enable_zoom_level(self, zoom: int) -> None:
+        if 0 <= zoom <= 19:
+            self._config_accessor().explorer_zoom_levels.append(zoom)
+            self._config_accessor().explorer_zoom_levels.sort()
+            self._config_accessor.save()
+            compute_tile_evolution(self._tile_visit_accessor, self._config_accessor())
+            flash(f"Enabled {zoom=} for explorer tiles.", category="success")
+        else:
+            flash(f"{zoom=} is not valid, must be between 0 and 19.", category="danger")
 
     def render(self, zoom: int) -> dict:
+        if zoom not in self._config_accessor().explorer_zoom_levels:
+            return {"zoom_level_not_generated": zoom}
+
         tile_evolution_states = self._tile_visit_accessor.states
         tile_visits = self._tile_visit_accessor.visits
         tile_histories = self._tile_visit_accessor.histories

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

@@ -1,9 +1,19 @@
 {% extends "page.html.j2" %}
 
 {% block container %}
+
+<h1>Explorer Tiles</h1>
+
+{% if zoom_level_not_generated %}
+<p>You try to access explorer tiles for a level that hasn't been generated before. That is not a problem, we just don't
+    generate all levels to save a bit of time. If you want to have it, just enable it!</p>
+
+<a href="{{ url_for('.enable_zoom_level', zoom=zoom_level_not_generated) }}" class="btn btn-primary">Enable Zoom {{
+    zoom_level_not_generated }}</a>
+{% else %}
+
 <div class="row mb-3">
     <div class="col">
-        <h1>Explorer Tiles</h1>
         <p>You have {{ explored.num_tiles }} explored tiles. There are {{ explored.num_cluster_tiles }} cluster tiles in
             total. Your largest cluster consists of {{ explored.max_cluster_size }} tiles. Your largest square has size
             {{
@@ -154,4 +164,5 @@
     </div>
 </div>
 
+{% endif %}
 {% endblock %}

geo_activity_playground/webui/settings/blueprint.py

@@ -0,0 +1,106 @@
+from typing import Optional
+
+from flask import Blueprint
+from flask import flash
+from flask import redirect
+from flask import render_template
+from flask import request
+from flask import url_for
+
+from geo_activity_playground.core.config import ConfigAccessor
+from geo_activity_playground.webui.settings.controller import SettingsController
+
+
+def int_or_none(s: str) -> Optional[int]:
+    if s:
+        try:
+            return int(s)
+        except ValueError as e:
+            flash(f"Cannot parse integer from {s}: {e}", category="danger")
+
+
+def make_settings_blueprint(config_accessor: ConfigAccessor) -> Blueprint:
+    settings_controller = SettingsController(config_accessor)
+    blueprint = Blueprint("settings", __name__, template_folder="templates")
+
+    @blueprint.route("/")
+    def index():
+        return render_template("settings/index.html.j2")
+
+    @blueprint.route("/equipment-offsets", methods=["GET", "POST"])
+    def equipment_offsets():
+        if request.method == "POST":
+            equipments = request.form.getlist("equipment")
+            offsets = request.form.getlist("offset")
+            settings_controller.save_equipment_offsets(equipments, offsets)
+        return render_template(
+            "settings/equipment-offsets.html.j2",
+            **settings_controller.render_equipment_offsets(),
+        )
+
+    @blueprint.route("/heart-rate", methods=["GET", "POST"])
+    def heart_rate():
+        if request.method == "POST":
+            birth_year = int_or_none(request.form["birth_year"])
+            heart_rate_resting = int_or_none(request.form["heart_rate_resting"])
+            if heart_rate_resting is None:
+                heart_rate_resting = 0
+            heart_rate_maximum = int_or_none(request.form["heart_rate_maximum"])
+            settings_controller.save_heart_rate(
+                birth_year, heart_rate_resting, heart_rate_maximum
+            )
+        return render_template(
+            "settings/heart-rate.html.j2", **settings_controller.render_heart_rate()
+        )
+
+    @blueprint.route("/kinds-without-achievements", methods=["GET", "POST"])
+    def kinds_without_achievements():
+        if request.method == "POST":
+            kinds = request.form.getlist("kind")
+            settings_controller.save_kinds_without_achievements(kinds)
+        return render_template(
+            "settings/kinds-without-achievements.html.j2",
+            **settings_controller.render_kinds_without_achievements(),
+        )
+
+    @blueprint.route("/metadata-extraction", methods=["GET", "POST"])
+    def metadata_extraction():
+        if request.method == "POST":
+            regexes = request.form.getlist("regex")
+            settings_controller.save_metadata_extraction(regexes)
+        return render_template(
+            "settings/metadata-extraction.html.j2",
+            **settings_controller.render_metadata_extraction(),
+        )
+
+    @blueprint.route("/privacy-zones", methods=["GET", "POST"])
+    def privacy_zones():
+        if request.method == "POST":
+            zone_names = request.form.getlist("zone_name")
+            zone_geojsons = request.form.getlist("zone_geojson")
+            settings_controller.save_privacy_zones(zone_names, zone_geojsons)
+        return render_template(
+            "settings/privacy-zones.html.j2",
+            **settings_controller.render_privacy_zones(),
+        )
+
+    @blueprint.route("/strava", methods=["GET", "POST"])
+    def strava():
+        if request.method == "POST":
+            strava_client_id = request.form["strava_client_id"]
+            strava_client_secret = request.form["strava_client_secret"]
+            url = settings_controller.save_strava(
+                strava_client_id, strava_client_secret
+            )
+            return redirect(url)
+        return render_template(
+            "settings/strava.html.j2", **settings_controller.render_strava()
+        )
+
+    @blueprint.route("/strava-callback")
+    def strava_callback():
+        code = request.args.get("code", type=str)
+        settings_controller.save_strava_code(code)
+        return redirect(url_for(".strava"))
+
+    return blueprint

geo_activity_playground/webui/settings/controller.py

@@ -0,0 +1,228 @@
+import json
+import re
+import urllib.parse
+from typing import Optional
+
+from flask import flash
+from flask import url_for
+
+from geo_activity_playground.core.config import ConfigAccessor
+from geo_activity_playground.core.heart_rate import HeartRateZoneComputer
+
+
+class SettingsController:
+    def __init__(self, config_accessor: ConfigAccessor) -> None:
+        self._config_accessor = config_accessor
+
+    def render_equipment_offsets(self) -> dict:
+        return {
+            "equipment_offsets": self._config_accessor().equipment_offsets,
+        }
+
+    def save_equipment_offsets(
+        self,
+        equipments: list[str],
+        offsets: list[str],
+    ) -> None:
+        assert len(equipments) == len(offsets)
+        new_equipment_offsets = {}
+        for equipment, offset_str in zip(equipments, offsets):
+            if not equipment or not offset_str:
+                continue
+
+            try:
+                offset = float(offset_str)
+            except ValueError as e:
+                flash(
+                    f"Cannot parse number {offset_str} for {equipment}: {e}",
+                    category="danger",
+                )
+                continue
+
+            if not offset:
+                continue
+
+            new_equipment_offsets[equipment] = offset
+        self._config_accessor().equipment_offsets = new_equipment_offsets
+        self._config_accessor.save()
+        flash("Updated equipment offsets.", category="success")
+
+    def render_heart_rate(self) -> dict:
+        result = {
+            "birth_year": self._config_accessor().birth_year,
+            "heart_rate_resting": self._config_accessor().heart_rate_resting,
+            "heart_rate_maximum": self._config_accessor().heart_rate_maximum,
+        }
+
+        self._heart_rate_computer = HeartRateZoneComputer(self._config_accessor())
+        try:
+            result["zone_boundaries"] = self._heart_rate_computer.zone_boundaries()
+        except RuntimeError as e:
+            pass
+        return result
+
+    def save_heart_rate(
+        self,
+        birth_year: Optional[int],
+        heart_rate_resting: Optional[int],
+        heart_rate_maximum: Optional[int],
+    ) -> None:
+        self._config_accessor().birth_year = birth_year
+        self._config_accessor().heart_rate_resting = heart_rate_resting
+        self._config_accessor().heart_rate_maximum = heart_rate_maximum
+        self._config_accessor.save()
+        flash("Updated heart rate data.", category="success")
+
+    def render_kinds_without_achievements(self) -> dict:
+        return {
+            "kinds_without_achievements": self._config_accessor().kinds_without_achievements,
+        }
+
+    def save_kinds_without_achievements(
+        self,
+        kinds: list[str],
+    ) -> None:
+        new_kinds = [kind.strip() for kind in kinds if kind.strip()]
+        new_kinds.sort()
+
+        self._config_accessor().kinds_without_achievements = new_kinds
+        self._config_accessor.save()
+        flash("Updated kinds without achievements.", category="success")
+
+    def render_metadata_extraction(self) -> dict:
+        return {
+            "metadata_extraction_regexes": self._config_accessor().metadata_extraction_regexes,
+        }
+
+    def save_metadata_extraction(
+        self,
+        metadata_extraction_regexes: list[str],
+    ) -> None:
+        new_metadata_extraction_regexes = []
+        for regex in metadata_extraction_regexes:
+            try:
+                re.compile(regex)
+            except re.error as e:
+                flash(
+                    f"Cannot parse regex {regex} due to error: {e}", category="danger"
+                )
+            else:
+                new_metadata_extraction_regexes.append(regex)
+
+        self._config_accessor().metadata_extraction_regexes = (
+            new_metadata_extraction_regexes
+        )
+        self._config_accessor.save()
+        flash("Updated metadata extraction settings.", category="success")
+
+    def render_privacy_zones(self) -> dict:
+        return {
+            "privacy_zones": {
+                name: _wrap_coordinates(coordinates)
+                for name, coordinates in self._config_accessor().privacy_zones.items()
+            }
+        }
+
+    def save_privacy_zones(
+        self, zone_names: list[str], zone_geojsons: list[str]
+    ) -> None:
+        assert len(zone_names) == len(zone_geojsons)
+        new_zone_config = {}
+
+        for zone_name, zone_geojson_str in zip(zone_names, zone_geojsons):
+            if not zone_name or not zone_geojson_str:
+                continue
+
+            try:
+                zone_geojson = json.loads(zone_geojson_str)
+            except json.decoder.JSONDecodeError as e:
+                flash(
+                    f"Could not parse GeoJSON for {zone_name} due to the following error: {e}"
+                )
+                continue
+
+            if not zone_geojson["type"] == "FeatureCollection":
+                flash(
+                    f"Pasted GeoJSON for {zone_name} must be of type 'FeatureCollection'.",
+                    category="danger",
+                )
+                continue
+
+            features = zone_geojson["features"]
+
+            if not len(features) == 1:
+                flash(
+                    f"Pasted GeoJSON for {zone_name} must contain exactly one feature. You cannot have multiple shapes for one privacy zone",
+                    category="danger",
+                )
+                continue
+
+            feature = features[0]
+            geometry = feature["geometry"]
+
+            if not geometry["type"] == "Polygon":
+                flash(
+                    f"Geometry for {zone_name} is not a polygon. You need to create a polygon (or circle or rectangle).",
+                    category="danger",
+                )
+                continue
+
+            coordinates = geometry["coordinates"]
+
+            if not len(coordinates) == 1:
+                flash(
+                    f"Polygon for {zone_name} consists of multiple polygons. Please supply a simple one.",
+                    category="danger",
+                )
+                continue
+
+            points = coordinates[0]
+
+            new_zone_config[zone_name] = points
+
+        self._config_accessor().privacy_zones = new_zone_config
+        self._config_accessor.save()
+        flash("Updated privacy zones.", category="success")
+
+    def render_strava(self) -> dict:
+        return {
+            "strava_client_id": self._config_accessor().strava_client_id,
+            "strava_client_secret": self._config_accessor().strava_client_secret,
+            "strava_client_code": self._config_accessor().strava_client_code,
+        }
+
+    def save_strava(self, client_id: str, client_secret: str) -> str:
+        self._strava_client_id = client_id
+        self._strava_client_secret = client_secret
+
+        payload = {
+            "client_id": client_id,
+            "redirect_uri": url_for(".strava_callback", _external=True),
+            "response_type": "code",
+            "scope": "activity:read_all",
+        }
+
+        arg_string = "&".join(
+            f"{key}={urllib.parse.quote(value)}" for key, value in payload.items()
+        )
+        return f"https://www.strava.com/oauth/authorize?{arg_string}"
+
+    def save_strava_code(self, code: str) -> None:
+        self._config_accessor().strava_client_id = self._strava_client_id
+        self._config_accessor().strava_client_secret = self._strava_client_secret
+        self._config_accessor().strava_client_code = code
+        self._config_accessor.save()
+        flash("Connected to Strava API", category="success")
+
+
+def _wrap_coordinates(coordinates: list[list[float]]) -> dict:
+    return {
+        "type": "FeatureCollection",
+        "features": [
+            {
+                "type": "Feature",
+                "properties": {},
+                "geometry": {"coordinates": [coordinates], "type": "Polygon"},
+            }
+        ],
+    }

geo_activity_playground/webui/settings/templates/settings/equipment-offsets.html.j2

@@ -0,0 +1,44 @@
+{% extends "page.html.j2" %}
+
+{% block container %}
+
+<h1 class="mb-3">Equipment Offsets</h1>
+
+<p>If you record every activity with an equipment but haven't started from the beginning, you might have a certain
+    distance that is not accounted for. In order to have this reflected in the equipment overview, you can enter offsets
+    here.</p>
+
+<form method="POST">
+    <div class="row row-cols-1 row-cols-md-3 g-4 mb-3">
+        {% for equipment, offset in equipment_offsets.items() %}
+        <div class="col-md-4">
+            <div class="mb-3">
+                <label for="equipment_{{ loop.index }}" class="form-label">Equipment</label>
+                <input type="text" class="form-control" id="equipment_{{ loop.index }}" name="equipment"
+                    value="{{ equipment }}" />
+            </div>
+            <div class="mb-3">
+                <label for="offset_{{ loop.index }}" class="form-label">Offset / km</label>
+                <input type="number" class="form-control" id="offset_{{ loop.index }}" name="offset"
+                    value="{{ offset }}" />
+            </div>
+        </div>
+        {% endfor %}
+
+        <div class="col-md-4">
+            <div class="mb-3">
+                <label for="equipment_new" class="form-label">Equipment</label>
+                <input type="text" class="form-control" id="equipment_new" name="equipment" />
+            </div>
+            <div class="mb-3">
+                <label for="offset_new" class="form-label">Offset / km</label>
+                <input type="number" class="form-control" id="offset_new" name="offset" />
+            </div>
+        </div>
+    </div>
+
+    <button type="submit" class="btn btn-primary">Save</button>
+</form>
+
+
+{% endblock %}

geo_activity_playground/webui/settings/templates/settings/heart-rate.html.j2

@@ -0,0 +1,102 @@
+{% extends "page.html.j2" %}
+
+{% block container %}
+
+<h1 class="mb-3">Heart Rate</h1>
+
+<p>If you have recorded activities with heart rate data, you can also let it display the heart rate zones.</p>
+
+<p>The definition of the heart rate zones is not standardized. Usually there are five zones and they have the same
+    names. What differs is how their ranges are computed and there is some chaos around that.</p>
+
+<p>All definitions that I found take the maximum heart rate as the upper limit. One can measure this as part of a
+    professional training or just use the <em>220 minus age</em> prescription which at least for me matches close
+    enough. What they differ on is how they use a lower bound. It seems that <a
+        href="https://www.polar.com/blog/running-heart-rate-zones-basics/">Polar</a> or <a
+        href="https://www.rei.com/learn/expert-advice/how-to-train-with-a-heart-rate-monitor.html">REI</a> basically use
+    0 as the lower bound. My Garmin system also uses 0 as the lower bound. But as one can see in <a
+        href="https://theathleteblog.com/heart-rate-zones/">this blog</a>, one can also use the resting heart rate as
+    the lower bound.</p>
+
+<p>Based on the maximum and resting heart rate we will then compute the heart rate zones using certain percentages of
+    <em>effort</em>. We can compute the heart rate as the following:
+</p>
+
+<blockquote>
+    <p>rate = effort × (maximum – minimum) + minimum</p>
+</blockquote>
+
+<div class="row mb-3">
+    <div class="col-md-4">
+        <form method="POST">
+            <div class="mb-3">
+                <label for="birth_year" class="form-label">Birth year</label>
+                <input type="text" class="form-control" id="birth_year" name="birth_year"
+                    value="{{ birth_year or '' }}" />
+            </div>
+            <div class="mb-3">
+                <label for="heart_rate_maximum" class="form-label">Maximum heart rate</label>
+                <input type="text" class="form-control" id="heart_rate_maximum" name="heart_rate_maximum"
+                    value="{{ heart_rate_maximum or '' }}" />
+            </div>
+            <div class="mb-3">
+                <label for="heart_rate_resting" class="form-label">Resting heart rate</label>
+                <input type="text" class="form-control" id="heart_rate_resting" name="heart_rate_resting"
+                    value="{{ heart_rate_resting or '' }}" />
+            </div>
+    <button type="submit" class="btn btn-primary">Save</button>
+        </form>
+    </div>
+
+    {% if zone_boundaries %}
+    <div class="col-md-8">
+        <p>Your heart rate zone boundaries:</p>
+        <table class="table">
+            <thead>
+                <tr>
+                    <td>Zone</td>
+                    <td>Percentage</td>
+                    <td>Heart rate</td>
+                    <td>Training</td>
+                </tr>
+            </thead>
+            <tbody>
+                <tr>
+                    <td>1</td>
+                    <td>50 to 60 %</td>
+                    <td>{{ zone_boundaries[0][0] }} to {{ zone_boundaries[0][1] }} Hz</td>
+                    <td>Warmup/Recovery</td>
+                </tr>
+                <tr>
+                    <td>2</td>
+                    <td>60 to 70 %</td>
+                    <td>{{ zone_boundaries[1][0] }} to {{ zone_boundaries[1][1] }} Hz</td>
+                    <td>Base Fitness</td>
+                </tr>
+                <tr>
+                    <td>3</td>
+                    <td>70 to 80 %</td>
+                    <td>{{ zone_boundaries[2][0] }} to {{ zone_boundaries[2][1] }} Hz</td>
+                    <td>Aerobic Endurance</td>
+                </tr>
+                <tr>
+                    <td>4</td>
+                    <td>80 to 90 %</td>
+                    <td>{{ zone_boundaries[3][0] }} to {{ zone_boundaries[3][1] }} Hz</td>
+                    <td>Anerobic Capacity</td>
+                </tr>
+                <tr>
+                    <td>5</td>
+                    <td>90 to 100 %</td>
+                    <td>{{ zone_boundaries[4][0] }} to {{ zone_boundaries[4][1] }} Hz</td>
+                    <td>Speed Training</td>
+                </tr>
+            </tbody>
+        </table>
+
+    </div>
+    {% endif %}
+
+</div>
+
+{% endblock %}