geo-activity-playground 0.38.2__py3-none-any.whl → 0.39.1__py3-none-any.whl

geo_activity_playground/webui/blueprints/settings_blueprint.py

@@ -0,0 +1,446 @@
+import json
+import re
+import shutil
+import urllib.parse
+from typing import Any
+from typing import Optional
+
+import sqlalchemy
+from flask import Blueprint
+from flask import flash
+from flask import redirect
+from flask import render_template
+from flask import request
+from flask import Response
+from flask import url_for
+
+from ...core.config import ConfigAccessor
+from ...core.datamodel import DB
+from ...core.datamodel import Equipment
+from ...core.datamodel import Kind
+from ...core.heart_rate import HeartRateZoneComputer
+from ...core.paths import _activity_enriched_dir
+from ..authenticator import Authenticator
+from ..authenticator import needs_authentication
+from ..flasher import Flasher
+from ..flasher import FlashTypes
+
+VEGA_COLOR_SCHEMES_CONTINUOUS = [
+    "lightgreyred",
+    "lightgreyteal",
+    "lightmulti",
+    "lightorange",
+    "lighttealblue",
+    "blues",
+    "tealblues",
+    "teals",
+    "greens",
+    "browns",
+    "oranges",
+    "reds",
+    "purples",
+    "warmgreys",
+    "greys",
+]
+
+MATPLOTLIB_COLOR_SCHEMES_CONTINUOUS = [
+    "afmhot",
+    "bone",
+    "cividis",
+    "copper",
+    "gist_gray",
+    "gist_heat",
+    "gnuplot2",
+    "gray",
+    "Greys_r",
+    "hot",
+    "inferno",
+    "magma",
+    "pink",
+    "plasma",
+    "viridis",
+]
+
+
+SHAREPIC_FIELDS = {
+    "calories": "Calories",
+    "distance_km": "Distance",
+    "elapsed_time": "Elapsed time",
+    "equipment": "Equipment",
+    "kind": "Kind",
+    "name": "Name",
+    "start": "Date",
+    "Steps": "Steps",
+}
+
+
+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")
+    return None
+
+
+def make_settings_blueprint(
+    config_accessor: ConfigAccessor, authenticator: Authenticator, flasher: Flasher
+) -> Blueprint:
+    strava_login_helper = StravaLoginHelper(config_accessor)
+    blueprint = Blueprint("settings", __name__, template_folder="templates")
+
+    @blueprint.route("/")
+    @needs_authentication(authenticator)
+    def index():
+        return render_template("settings/index.html.j2")
+
+    @blueprint.route("/admin-password")
+    @needs_authentication(authenticator)
+    def admin_password() -> Response:
+        if request.method == "POST":
+            config_accessor().upload_password = request.form["password"]
+            config_accessor.save()
+            flasher.flash_message("Updated admin password.", FlashTypes.SUCCESS)
+        return render_template(
+            "settings/admin-password.html.j2",
+            password=config_accessor().upload_password,
+        )
+
+    @blueprint.route("/color-schemes", methods=["GET", "POST"])
+    @needs_authentication(authenticator)
+    def color_schemes():
+        if request.method == "POST":
+            config_accessor().color_scheme_for_counts = request.form[
+                "color_scheme_for_counts"
+            ]
+            config_accessor().color_scheme_for_kind = request.form[
+                "color_scheme_for_kind"
+            ]
+            config_accessor().color_scheme_for_heatmap = request.form[
+                "color_scheme_for_heatmap"
+            ]
+            config_accessor.save()
+            flash("Updated color schemes.", category="success")
+
+        return render_template(
+            "settings/color-schemes.html.j2",
+            color_scheme_for_counts=config_accessor().color_scheme_for_counts,
+            color_scheme_for_counts_avail=VEGA_COLOR_SCHEMES_CONTINUOUS,
+            color_scheme_for_kind=config_accessor().color_scheme_for_kind,
+            color_scheme_for_kind_avail=[
+                "accent",
+                "category10",
+                "category20",
+                "category20b",
+                "category20c",
+                "dark2",
+                "paired",
+                "pastel1",
+                "pastel2",
+                "set1",
+                "set2",
+                "set3",
+                "tableau10",
+                "tableau20",
+            ],
+            color_scheme_for_heatmap=config_accessor().color_scheme_for_heatmap,
+            color_scheme_for_heatmap_avail=MATPLOTLIB_COLOR_SCHEMES_CONTINUOUS,
+        )
+
+    @blueprint.route("/manage-equipments", methods=["GET", "POST"])
+    @needs_authentication(authenticator)
+    def manage_equipments():
+        if request.method == "POST":
+            ids = request.form.getlist("id")
+            names = request.form.getlist("name")
+            offsets = request.form.getlist("offset_km")
+            assert len(ids) == len(names) == len(offsets)
+            for id, name, offset in zip(ids, names, offsets):
+                if id:
+                    equipment = DB.session.get(Equipment, int(id))
+                    equipment.name = name
+                    equipment.offset_km = int(float(offset))
+                if not id and name:
+                    equipment = Equipment(name)
+                    if offset:
+                        equipment.offset_km = int(float(offset))
+                    DB.session.add(equipment)
+                    flasher.flash_message(
+                        f"Equipment '{name}' added.", FlashTypes.SUCCESS
+                    )
+            DB.session.commit()
+        equipments = DB.session.scalars(
+            sqlalchemy.select(Equipment).order_by(Equipment.name)
+        ).all()
+        return render_template(
+            "settings/manage-equipments.html.j2",
+            equipments=equipments,
+        )
+
+    @blueprint.route("/manage-kinds", methods=["GET", "POST"])
+    @needs_authentication(authenticator)
+    def manage_kinds():
+        if request.method == "POST":
+            print(request.form)
+            ids = request.form.getlist("id")
+            names = request.form.getlist("name")
+            consider_for_achievements = request.form.getlist(
+                "consider_for_achievements"
+            )
+            assert len(ids) == len(names)
+            for id, name in zip(ids, names):
+                if id:
+                    kind = DB.session.get(Kind, int(id))
+                    kind.name = name
+                    kind.consider_for_achievements = id in consider_for_achievements
+                if not id and name:
+                    kind = Kind(name)
+                    if consider_for_achievements:
+                        kind.consider_for_achievements = (
+                            "new" in consider_for_achievements
+                        )
+                    DB.session.add(kind)
+                    flasher.flash_message(f"Kind '{name}' added.", FlashTypes.SUCCESS)
+            DB.session.commit()
+        kinds = DB.session.scalars(sqlalchemy.select(Kind).order_by(Kind.name)).all()
+        return render_template(
+            "settings/manage-kinds.html.j2",
+            kinds=kinds,
+        )
+
+    @blueprint.route("/heart-rate", methods=["GET", "POST"])
+    @needs_authentication(authenticator)
+    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"])
+            config_accessor().birth_year = birth_year
+            config_accessor().heart_rate_resting = heart_rate_resting or 0
+            config_accessor().heart_rate_maximum = heart_rate_maximum
+            config_accessor.save()
+            flash("Updated heart rate data.", category="success")
+
+        context: dict[str, Any] = {
+            "birth_year": config_accessor().birth_year,
+            "heart_rate_resting": config_accessor().heart_rate_resting,
+            "heart_rate_maximum": config_accessor().heart_rate_maximum,
+        }
+
+        heart_rate_computer = HeartRateZoneComputer(config_accessor())
+        try:
+            context["zone_boundaries"] = heart_rate_computer.zone_boundaries()
+        except RuntimeError as e:
+            pass
+        return render_template("settings/heart-rate.html.j2", **context)
+
+    @blueprint.route("/metadata-extraction", methods=["GET", "POST"])
+    @needs_authentication(authenticator)
+    def metadata_extraction():
+        if request.method == "POST":
+            metadata_extraction_regexes = request.form.getlist("regex")
+            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)
+
+            config_accessor().metadata_extraction_regexes = (
+                new_metadata_extraction_regexes
+            )
+            config_accessor.save()
+            flash("Updated metadata extraction settings.", category="success")
+        context = {
+            "metadata_extraction_regexes": config_accessor().metadata_extraction_regexes,
+        }
+        return render_template("settings/metadata-extraction.html.j2", **context)
+
+    @blueprint.route("/privacy-zones", methods=["GET", "POST"])
+    @needs_authentication(authenticator)
+    def privacy_zones():
+        if request.method == "POST":
+            zone_names = request.form.getlist("zone_name")
+            zone_geojsons = request.form.getlist("zone_geojson")
+            strava_login_helper.save_privacy_zones(zone_names, zone_geojsons)
+
+            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
+
+            config_accessor().privacy_zones = new_zone_config
+            config_accessor.save()
+            flash("Updated privacy zones.", category="success")
+
+        context = {
+            "privacy_zones": {
+                name: _wrap_coordinates(coordinates)
+                for name, coordinates in config_accessor().privacy_zones.items()
+            }
+        }
+        return render_template("settings/privacy-zones.html.j2", **context)
+
+    @blueprint.route("/segmentation", methods=["GET", "POST"])
+    @needs_authentication(authenticator)
+    def segmentation():
+        if request.method == "POST":
+            threshold = int(request.form.get("threshold", 0))
+            config_accessor().time_diff_threshold_seconds = threshold
+            config_accessor.save()
+            flash(f"Threshold set to {threshold}.", category="success")
+            shutil.rmtree(_activity_enriched_dir)
+            return redirect(url_for("upload.reload"))
+        return render_template(
+            "settings/segmentation.html.j2",
+            threshold=config_accessor().time_diff_threshold_seconds,
+        )
+
+    @blueprint.route("/sharepic", methods=["GET", "POST"])
+    @needs_authentication(authenticator)
+    def sharepic():
+        if request.method == "POST":
+            names = request.form.getlist("name")
+            config_accessor().sharepic_suppressed_fields = list(
+                set(SHAREPIC_FIELDS) - set(names)
+            )
+            config_accessor.save()
+            flash("Updated sharepic preferences.", category="success")
+        return render_template(
+            "settings/sharepic.html.j2",
+            names=[
+                (
+                    name,
+                    label,
+                    name not in config_accessor().sharepic_suppressed_fields,
+                )
+                for name, label in SHAREPIC_FIELDS.items()
+            ],
+        )
+
+    @blueprint.route("/strava", methods=["GET", "POST"])
+    @needs_authentication(authenticator)
+    def strava():
+        if request.method == "POST":
+            strava_client_id = request.form["strava_client_id"]
+            strava_client_secret = request.form["strava_client_secret"]
+            url = strava_login_helper.save_strava(
+                strava_client_id, strava_client_secret
+            )
+            return redirect(url)
+        return render_template(
+            "settings/strava.html.j2", **strava_login_helper.render_strava()
+        )
+
+    @blueprint.route("/strava-callback")
+    @needs_authentication(authenticator)
+    def strava_callback():
+        code = request.args.get("code", type=str)
+        strava_login_helper.save_strava_code(code)
+        return redirect(url_for(".strava"))
+
+    return blueprint
+
+
+def _wrap_coordinates(coordinates: list[list[float]]) -> dict:
+    return {
+        "type": "FeatureCollection",
+        "features": [
+            {
+                "type": "Feature",
+                "properties": {},
+                "geometry": {"coordinates": [coordinates], "type": "Polygon"},
+            }
+        ],
+    }
+
+
+class StravaLoginHelper:
+    def __init__(self, config_accessor: ConfigAccessor) -> None:
+        self._config_accessor = config_accessor
+
+    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 = int(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")

geo_activity_playground/webui/{square_planner_blueprint.py → blueprints/square_planner_blueprint.py}

@@ -1,16 +1,20 @@
 import geojson
+import sqlalchemy
 from flask import Blueprint
 from flask import redirect
 from flask import render_template
+from flask import request
 from flask import Response
 from flask import url_for
 
-from geo_activity_playground.explorer.grid_file import make_explorer_rectangle
-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 TileVisitAccessor
+from ...core.datamodel import DB
+from ...core.datamodel import SquarePlannerBookmark
+from ...explorer.grid_file import make_explorer_rectangle
+from ...explorer.grid_file import make_explorer_tile
+from ...explorer.grid_file import make_grid_file_geojson
+from ...explorer.grid_file import make_grid_file_gpx
+from ...explorer.grid_file import make_grid_points
+from ...explorer.tile_visits import TileVisitAccessor
 
 
 def make_square_planner_blueprint(tile_visit_accessor: TileVisitAccessor) -> Blueprint:
@@ -72,6 +76,9 @@ def make_square_planner_blueprint(tile_visit_accessor: TileVisitAccessor) -> Blu
             square_x=x,
             square_y=y,
             square_size=size,
+            bookmarks=DB.session.scalars(
+                sqlalchemy.select(SquarePlannerBookmark)
+            ).all(),
         )
 
     @blueprint.route("/<int:zoom>/<int:x>/<int:y>/<int:size>/missing.<suffix>")
@@ -99,6 +106,24 @@ def make_square_planner_blueprint(tile_visit_accessor: TileVisitAccessor) -> Blu
             headers={"Content-disposition": "attachment"},
         )
 
+    @blueprint.route(
+        "/save-bookmark/<int:zoom>/<int:x>/<int:y>/<int:size>", methods=["POST"]
+    )
+    def save_bookmark(zoom: int, x: int, y: int, size: int):
+        bookmark = SquarePlannerBookmark(
+            zoom=zoom, x=x, y=y, size=size, name=request.form["name"]
+        )
+        DB.session.add(bookmark)
+        DB.session.commit()
+        return redirect(request.referrer)
+
+    @blueprint.route("/delete-bookmark/<int:id>")
+    def delete_bookmark(id: int):
+        bookmark = DB.session.get(SquarePlannerBookmark, id)
+        DB.session.delete(bookmark)
+        DB.session.commit()
+        return redirect(request.referrer)
+
     return blueprint
 
 

geo_activity_playground/webui/{summary_blueprint.py → blueprints/summary_blueprint.py}

@@ -7,13 +7,13 @@ from flask import Blueprint
 from flask import render_template
 from flask import request
 
-from geo_activity_playground.core.activities import ActivityRepository
-from geo_activity_playground.core.activities import make_geojson_from_time_series
-from geo_activity_playground.core.config import Config
-from geo_activity_playground.core.meta_search import apply_search_query
-from geo_activity_playground.webui.plot_util import make_kind_scale
-from geo_activity_playground.webui.search_util import search_query_from_form
-from geo_activity_playground.webui.search_util import SearchQueryHistory
+from ...core.activities import ActivityRepository
+from ...core.activities import make_geojson_from_time_series
+from ...core.config import Config
+from ...core.meta_search import apply_search_query
+from ..plot_util import make_kind_scale
+from ..search_util import search_query_from_form
+from ..search_util import SearchQueryHistory
 
 
 def make_summary_blueprint(
@@ -30,8 +30,7 @@ def make_summary_blueprint(
         activities = apply_search_query(repository.meta, query)
 
         kind_scale = make_kind_scale(repository.meta, config)
-        df = embellished_activities(activities)
-        # df = df.loc[df["consider_for_achievements"]]
+        df = activities
 
         year_kind_total = (
             df[["year", "kind", "distance_km", "hours"]]
@@ -40,6 +39,8 @@ def make_summary_blueprint(
             .reset_index()
         )
 
+        nominations = nominate_activities(df)
+
         return render_template(
             "summary/index.html.j2",
             plot_distance_heatmaps=plot_distance_heatmaps(df, config),
@@ -58,7 +59,7 @@ def make_summary_blueprint(
                         repository.get_time_series(activity_id)
                     ),
                 )
-                for activity_id, reasons in nominate_activities(df).items()
+                for activity_id, reasons in nominations.items()
             ],
             query=query.to_jinja(),
         )
@@ -100,19 +101,6 @@ def _nominate_activities_inner(
             nominations[i].append(f"{title}{title_suffix}: {format_applied}")
 
 
-def embellished_activities(meta: pd.DataFrame) -> pd.DataFrame:
-    df = meta.loc[~pd.isna(meta["start"])].copy()
-    df["year"] = [start.year for start in df["start"]]
-    df["month"] = [start.month for start in df["start"]]
-    df["day"] = [start.day for start in df["start"]]
-    df["week"] = [start.isocalendar().week for start in df["start"]]
-    df["iso_year"] = [start.isocalendar().year for start in df["start"]]
-    df["hours"] = [
-        elapsed_time.total_seconds() / 3600 for elapsed_time in df["elapsed_time"]
-    ]
-    return df
-
-
 def plot_distance_heatmaps(meta: pd.DataFrame, config: Config) -> dict[int, str]:
     return {
         year: alt.Chart(

geo_activity_playground/webui/blueprints/tile_blueprint.py

@@ -0,0 +1,27 @@
+import io
+
+import matplotlib.pyplot as pl
+import numpy as np
+from flask import Blueprint
+from flask import Response
+
+from ...core.raster_map import ImageTransform
+from ...core.raster_map import TileGetter
+
+
+def make_tile_blueprint(
+    image_transforms: dict[str, ImageTransform],
+    tile_getter: TileGetter,
+) -> Blueprint:
+
+    blueprint = Blueprint("tile", __name__, template_folder="templates")
+
+    @blueprint.route("/<scheme>/<int:z>/<int:x>/<int:y>.png")
+    def tile(scheme: str, z: int, x: int, y: int) -> Response:
+        map_tile = np.array(tile_getter.get_tile(z, x, y)) / 255
+        transformed_tile = image_transforms[scheme].transform_image(map_tile)
+        f = io.BytesIO()
+        pl.imsave(f, transformed_tile, format="png")
+        return Response(bytes(f.getbuffer()), mimetype="image/png")
+
+    return blueprint

geo_activity_playground/webui/{upload_blueprint.py → blueprints/upload_blueprint.py}

@@ -8,21 +8,18 @@ from flask import render_template
 from flask import request
 from flask import url_for
 
-from ..core.activities import ActivityRepository
-from ..core.activities import build_activity_meta
-from ..explorer.tile_visits import compute_tile_evolution
-from ..explorer.tile_visits import compute_tile_visits_new
-from ..explorer.tile_visits import TileVisitAccessor
-from geo_activity_playground.core.config import Config
-from geo_activity_playground.core.enrichment import enrich_activities
-from geo_activity_playground.importers.directory import get_file_hash
-from geo_activity_playground.importers.directory import import_from_directory
-from geo_activity_playground.importers.strava_api import import_from_strava_api
-from geo_activity_playground.importers.strava_checkout import (
-    import_from_strava_checkout,
-)
-from geo_activity_playground.webui.authenticator import Authenticator
-from geo_activity_playground.webui.authenticator import needs_authentication
+from ...core.activities import ActivityRepository
+from ...core.config import Config
+from ...core.enrichment import populate_database_from_extracted
+from ...explorer.tile_visits import compute_tile_evolution
+from ...explorer.tile_visits import compute_tile_visits_new
+from ...explorer.tile_visits import TileVisitAccessor
+from ...importers.directory import get_file_hash
+from ...importers.directory import import_from_directory
+from ...importers.strava_api import import_from_strava_api
+from ...importers.strava_checkout import import_from_strava_checkout
+from ..authenticator import Authenticator
+from ..authenticator import needs_authentication
 
 
 def make_upload_blueprint(
@@ -114,9 +111,7 @@ def scan_for_activities(
     if config.strava_client_code and not skip_strava:
         import_from_strava_api(config)
 
-    enrich_activities(config)
-    build_activity_meta()
-    repository.reload()
+    populate_database_from_extracted(config)
 
     if len(repository) > 0:
         compute_tile_visits_new(repository, tile_visit_accessor)

geo_activity_playground/webui/flasher.py

@@ -0,0 +1,26 @@
+import abc
+from enum import Enum
+
+import flask
+
+
+class FlashTypes(Enum):
+    PRIMARY = "primary"
+    SECONDARY = "secondary"
+    SUCCESS = "success"
+    DANGER = "danger"
+    WARNING = "warning"
+    INFO = "info"
+    LIGHT = "light"
+    DARK = "dark"
+
+
+class Flasher(abc.ABC):
+    @abc.abstractmethod
+    def flash_message(self, message: str, type: FlashTypes):
+        pass
+
+
+class FlaskFlasher(Flasher):
+    def flash_message(self, message, type):
+        flask.flash(message, category=type.value)

geo_activity_playground/webui/plot_util.py

@@ -1,7 +1,7 @@
 import altair as alt
 import pandas as pd
 
-from geo_activity_playground.core.config import Config
+from ..core.config import Config
 
 
 def make_kind_scale(meta: pd.DataFrame, config: Config) -> alt.Scale: