geo-activity-playground 0.27.1__py3-none-any.whl → 0.29.0__py3-none-any.whl

geo_activity_playground/webui/app.py

@@ -5,7 +5,6 @@ import secrets
 
 from flask import Flask
 from flask import render_template
-from flask import request
 
 from ..core.activities import ActivityRepository
 from ..explorer.tile_visits import TileVisitAccessor
@@ -16,29 +15,20 @@ 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 .search.blueprint import make_search_blueprint
 from .square_planner.blueprint import make_square_planner_blueprint
 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.config import Config
 from geo_activity_playground.core.config import ConfigAccessor
+from geo_activity_playground.webui.auth.blueprint import make_auth_blueprint
+from geo_activity_playground.webui.authenticator import Authenticator
 from geo_activity_playground.webui.settings.blueprint import make_settings_blueprint
 
 
-def route_search(app: Flask, repository: ActivityRepository) -> None:
-    search_controller = SearchController(repository)
-
-    @app.route("/search", methods=["POST"])
-    def search():
-        form_input = request.form
-        return render_template(
-            "search.html.j2",
-            **search_controller.render_search_results(form_input["name"])
-        )
-
-
-def route_start(app: Flask, repository: ActivityRepository) -> None:
-    entry_controller = EntryController(repository)
+def route_start(app: Flask, repository: ActivityRepository, config: Config) -> None:
+    entry_controller = EntryController(repository, config)
 
     @app.route("/")
     def index():
@@ -64,15 +54,17 @@ def web_ui_main(
     host: str,
     port: int,
 ) -> None:
-
     repository.reload()
 
     app = Flask(__name__)
     app.config["UPLOAD_FOLDER"] = "Activities"
     app.secret_key = get_secret_key()
 
-    route_search(app, repository)
-    route_start(app, repository)
+    authenticator = Authenticator(config_accessor())
+
+    route_start(app, repository, config_accessor())
+
+    app.register_blueprint(make_auth_blueprint(authenticator), url_prefix="/auth")
 
     app.register_blueprint(
         make_activity_blueprint(
@@ -97,7 +89,7 @@ def web_ui_main(
         make_heatmap_blueprint(repository, tile_visit_accessor), url_prefix="/heatmap"
     )
     app.register_blueprint(
-        make_settings_blueprint(config_accessor),
+        make_settings_blueprint(config_accessor, authenticator),
         url_prefix="/settings",
     )
     app.register_blueprint(
@@ -105,12 +97,18 @@ def web_ui_main(
         url_prefix="/square-planner",
     )
     app.register_blueprint(
-        make_summary_blueprint(repository),
+        make_search_blueprint(repository),
+        url_prefix="/search",
+    )
+    app.register_blueprint(
+        make_summary_blueprint(repository, config_accessor()),
         url_prefix="/summary",
     )
     app.register_blueprint(make_tile_blueprint(), url_prefix="/tile")
     app.register_blueprint(
-        make_upload_blueprint(repository, tile_visit_accessor, config_accessor()),
+        make_upload_blueprint(
+            repository, tile_visit_accessor, config_accessor(), authenticator
+        ),
         url_prefix="/upload",
     )
 

geo_activity_playground/webui/auth/blueprint.py

@@ -0,0 +1,27 @@
+from flask import Blueprint
+from flask import redirect
+from flask import render_template
+from flask import request
+from flask import url_for
+
+from geo_activity_playground.webui.authenticator import Authenticator
+
+
+def make_auth_blueprint(authenticator: Authenticator) -> Blueprint:
+    blueprint = Blueprint("auth", __name__, template_folder="templates")
+
+    @blueprint.route("/", methods=["GET", "POST"])
+    def index():
+        if request.method == "POST":
+            authenticator.authenticate(request.form["password"])
+        return render_template(
+            "auth/index.html.j2",
+            is_authenticated=authenticator.is_authenticated(),
+        )
+
+    @blueprint.route("/logout")
+    def logout():
+        authenticator.logout()
+        return redirect(url_for(".index"))
+
+    return blueprint

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

@@ -0,0 +1,21 @@
+{% extends "page.html.j2" %}
+
+{% block container %}
+<h1>Authentication</h1>
+
+{% if is_authenticated %}
+<p>You are either logged in or don't have a password set. You can do everything.</p>
+
+<a class="btn btn-primary" href="{{ url_for('.logout') }}">Log Out</a>
+{% else %}
+<form method="POST">
+    <div class="mb-3">
+        <label for="password" class="form-label">Password</label>
+        <input type="password" class="form-control" id="password" name="password" />
+    </div>
+
+    <button type="submit" class="btn btn-primary">Log In</button>
+</form>
+{% endif %}
+
+{% endblock %}

geo_activity_playground/webui/authenticator.py

@@ -0,0 +1,46 @@
+import functools
+from typing import Callable
+
+from flask import flash
+from flask import redirect
+from flask import session
+from flask import url_for
+
+from geo_activity_playground.core.config import Config
+
+
+class Authenticator:
+    def __init__(self, config: Config) -> None:
+        self._config = config
+
+    def is_authenticated(self) -> bool:
+        return not self._config.upload_password or session.get(
+            "is_authenticated", False
+        )
+
+    def authenticate(self, password: str) -> None:
+        if password == self._config.upload_password:
+            session["is_authenticated"] = True
+            session.permanent = True
+            flash("Login successful.", category="success")
+        else:
+            flash("Incorrect password.", category="warning")
+
+    def logout(self) -> None:
+        session["is_authenticated"] = False
+        flash("Logout successful.", category="success")
+
+
+def needs_authentication(authenticator: Authenticator) -> Callable:
+    def decorator(route: Callable) -> Callable:
+        @functools.wraps(route)
+        def wrapped_route(*args, **kwargs):
+            if authenticator.is_authenticated():
+                return route(*args, **kwargs)
+            else:
+                flash("You need to be logged in to view that site.", category="Warning")
+                return redirect(url_for("auth.index"))
+
+        return wrapped_route
+
+    return decorator

geo_activity_playground/webui/entry_controller.py

@@ -6,18 +6,22 @@ import pandas as pd
 
 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.webui.plot_util import make_kind_scale
 
 
 class EntryController:
-    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_scale = make_kind_scale(self._repository.meta, self._config)
         result = {"latest_activities": []}
 
         if len(self._repository):
             result["distance_last_30_days_plot"] = distance_last_30_days_meta_plot(
-                self._repository.meta
+                self._repository.meta, kind_scale
             )
 
         for activity in itertools.islice(
@@ -33,7 +37,7 @@ class EntryController:
         return result
 
 
-def distance_last_30_days_meta_plot(meta: pd.DataFrame) -> str:
+def distance_last_30_days_meta_plot(meta: pd.DataFrame, kind_scale: alt.Scale) -> str:
     before_30_days = pd.to_datetime(
         datetime.datetime.now() - datetime.timedelta(days=31)
     )
@@ -48,7 +52,7 @@ def distance_last_30_days_meta_plot(meta: pd.DataFrame) -> str:
         .encode(
             alt.X("yearmonthdate(start)", title="Date"),
             alt.Y("sum(distance_km)", title="Distance / km"),
-            alt.Color("kind", scale=alt.Scale(scheme="category10"), title="Kind"),
+            alt.Color("kind", scale=kind_scale, title="Kind"),
             [
                 alt.Tooltip("yearmonthdate(start)", title="Date"),
                 alt.Tooltip("kind", title="Kind"),

geo_activity_playground/webui/equipment/controller.py

@@ -103,7 +103,8 @@ class EquipmentController:
             }
 
         for equipment, offset in self._config.equipment_offsets.items():
-            equipment_summary.loc[equipment, "total_distance_km"] += offset
+            if equipment in equipment_summary.index:
+                equipment_summary.loc[equipment, "total_distance_km"] += offset
 
         return {
             "equipment_variables": equipment_variables,

geo_activity_playground/webui/explorer/controller.py

@@ -54,9 +54,9 @@ class ExplorerController:
         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
+        tile_evolution_states = self._tile_visit_accessor.tile_state["evolution_state"]
+        tile_visits = self._tile_visit_accessor.tile_state["tile_visits"]
+        tile_histories = self._tile_visit_accessor.tile_state["tile_history"]
 
         medians = tile_histories[zoom].median()
         median_lat, median_lon = get_tile_upper_left_lat_lon(
@@ -161,6 +161,7 @@ def get_three_color_tiles(
             "last_visit": tile_data["last_time"].date().isoformat(),
             "num_visits": len(tile_data["activity_ids"]),
             "square": False,
+            "tile": f"({zoom}, {tile[0]}, {tile[1]})",
         }
 
     # Mark biggest square.

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

@@ -48,6 +48,8 @@
             function onEachFeature(feature, layer) {
                 if (feature.properties && feature.properties.first_visit) {
                     let lines = [
+                        `<dt>Tile</dt>`,
+                        `<dd>${feature.properties.tile}</dd>`,
                         `<dt>First visit</dt>`,
                         `<dd>${feature.properties.first_visit}</br><a href=/activity/${feature.properties.first_activity_id}>${feature.properties.first_activity_name}</a></dd>`,
                         `<dt>Last visit</dt>`,

geo_activity_playground/webui/heatmap/heatmap_controller.py

@@ -34,10 +34,14 @@ class HeatmapController:
         self._repository = repository
         self._tile_visit_accessor = tile_visit_accessor
 
-        self.tile_histories = self._tile_visit_accessor.histories
-        self.tile_evolution_states = self._tile_visit_accessor.states
-        self.tile_visits = self._tile_visit_accessor.visits
-        self.activities_per_tile = self._tile_visit_accessor.activities_per_tile
+        self.tile_histories = self._tile_visit_accessor.tile_state["tile_history"]
+        self.tile_evolution_states = self._tile_visit_accessor.tile_state[
+            "evolution_state"
+        ]
+        self.tile_visits = self._tile_visit_accessor.tile_state["tile_visits"]
+        self.activities_per_tile = self._tile_visit_accessor.tile_state[
+            "activities_per_tile"
+        ]
 
     def render(self, kinds: list[str] = []) -> dict:
         zoom = 14
@@ -74,7 +78,14 @@ class HeatmapController:
         tile_pixels = (OSM_TILE_SIZE, OSM_TILE_SIZE)
         tile_count_cache_path = pathlib.Path(f"Cache/Heatmap/{kind}/{z}/{x}/{y}.npy")
         if tile_count_cache_path.exists():
-            tile_counts = np.load(tile_count_cache_path)
+            try:
+                tile_counts = np.load(tile_count_cache_path)
+            except ValueError:
+                logger.warning(
+                    f"Heatmap count file {tile_count_cache_path} is corrupted, deleting."
+                )
+                tile_count_cache_path.unlink()
+                tile_counts = np.zeros(tile_pixels, dtype=np.int32)
         else:
             tile_counts = np.zeros(tile_pixels, dtype=np.int32)
         tile_count_cache_path.parent.mkdir(parents=True, exist_ok=True)
@@ -110,7 +121,10 @@ class HeatmapController:
                         draw.line(pixels, fill=1, width=max(3, 6 * (z - 17)))
                         aim = np.array(im)
                         tile_counts += aim
-            np.save(tile_count_cache_path, tile_counts)
+            tmp_path = tile_count_cache_path.with_suffix(".tmp.npy")
+            np.save(tmp_path, tile_counts)
+            tile_count_cache_path.unlink(missing_ok=True)
+            tmp_path.rename(tile_count_cache_path)
         return tile_counts
 
     def _render_tile_image(

geo_activity_playground/webui/plot_util.py

@@ -0,0 +1,9 @@
+import altair as alt
+import pandas as pd
+
+from geo_activity_playground.core.config import Config
+
+
+def make_kind_scale(meta: pd.DataFrame, config: Config) -> alt.Scale:
+    kinds = sorted(meta["kind"].unique())
+    return alt.Scale(domain=kinds, scheme=config.color_scheme_for_kind)

geo_activity_playground/webui/search/blueprint.py

@@ -0,0 +1,20 @@
+from flask import Blueprint
+from flask import render_template
+from flask import request
+from flask import Response
+
+from ...core.activities import ActivityRepository
+
+
+def make_search_blueprint(repository: ActivityRepository) -> Blueprint:
+    blueprint = Blueprint("search", __name__, template_folder="templates")
+
+    @blueprint.route("/", methods=["POST"])
+    def index():
+        activities = []
+        for _, row in repository.meta.iterrows():
+            if request.form["name"] in row["name"]:
+                activities.append(row)
+        return render_template("search/index.html.j2", activities=activities)
+
+    return blueprint

geo_activity_playground/webui/settings/blueprint.py

@@ -8,6 +8,8 @@ from flask import request
 from flask import url_for
 
 from geo_activity_playground.core.config import ConfigAccessor
+from geo_activity_playground.webui.authenticator import Authenticator
+from geo_activity_playground.webui.authenticator import needs_authentication
 from geo_activity_playground.webui.settings.controller import SettingsController
 
 
@@ -19,15 +21,96 @@ def int_or_none(s: str) -> Optional[int]:
             flash(f"Cannot parse integer from {s}: {e}", category="danger")
 
 
-def make_settings_blueprint(config_accessor: ConfigAccessor) -> Blueprint:
+def make_settings_blueprint(
+    config_accessor: ConfigAccessor, authenticator: Authenticator
+) -> Blueprint:
     settings_controller = SettingsController(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", methods=["GET", "POST"])
+    @needs_authentication(authenticator)
+    def admin_password():
+        if request.method == "POST":
+            settings_controller.save_admin_password(request.form["password"])
+        return render_template(
+            "settings/admin-password.html.j2",
+            **settings_controller.render_admin_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.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=[
+                "viridis",
+                "magma",
+                "inferno",
+                "plasma",
+                "cividis",
+                "turbo",
+                "bluegreen",
+                "bluepurple",
+                "goldgreen",
+                "goldorange",
+                "goldred",
+                "greenblue",
+                "orangered",
+                "purplebluegreen",
+                "purpleblue",
+                "purplered",
+                "redpurple",
+                "yellowgreenblue",
+                "yellowgreen",
+                "yelloworangebrown",
+                "yelloworangered",
+                "darkblue",
+                "darkgold",
+                "darkgreen",
+                "darkmulti",
+                "darkred",
+                "lightgreyred",
+                "lightgreyteal",
+                "lightmulti",
+                "lightorange",
+                "lighttealblue",
+            ],
+            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",
+            ],
+        )
+
     @blueprint.route("/equipment-offsets", methods=["GET", "POST"])
+    @needs_authentication(authenticator)
     def equipment_offsets():
         if request.method == "POST":
             equipments = request.form.getlist("equipment")
@@ -39,6 +122,7 @@ def make_settings_blueprint(config_accessor: ConfigAccessor) -> Blueprint:
         )
 
     @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"])
@@ -54,6 +138,7 @@ def make_settings_blueprint(config_accessor: ConfigAccessor) -> Blueprint:
         )
 
     @blueprint.route("/kinds-without-achievements", methods=["GET", "POST"])
+    @needs_authentication(authenticator)
     def kinds_without_achievements():
         if request.method == "POST":
             kinds = request.form.getlist("kind")
@@ -64,6 +149,7 @@ def make_settings_blueprint(config_accessor: ConfigAccessor) -> Blueprint:
         )
 
     @blueprint.route("/metadata-extraction", methods=["GET", "POST"])
+    @needs_authentication(authenticator)
     def metadata_extraction():
         if request.method == "POST":
             regexes = request.form.getlist("regex")
@@ -74,6 +160,7 @@ def make_settings_blueprint(config_accessor: ConfigAccessor) -> Blueprint:
         )
 
     @blueprint.route("/privacy-zones", methods=["GET", "POST"])
+    @needs_authentication(authenticator)
     def privacy_zones():
         if request.method == "POST":
             zone_names = request.form.getlist("zone_name")
@@ -84,7 +171,19 @@ def make_settings_blueprint(config_accessor: ConfigAccessor) -> Blueprint:
             **settings_controller.render_privacy_zones(),
         )
 
+    @blueprint.route("/sharepic", methods=["GET", "POST"])
+    @needs_authentication(authenticator)
+    def sharepic():
+        if request.method == "POST":
+            names = request.form.getlist("name")
+            settings_controller.save_sharepic(names)
+        return render_template(
+            "settings/sharepic.html.j2",
+            **settings_controller.render_sharepic(),
+        )
+
     @blueprint.route("/strava", methods=["GET", "POST"])
+    @needs_authentication(authenticator)
     def strava():
         if request.method == "POST":
             strava_client_id = request.form["strava_client_id"]
@@ -98,6 +197,7 @@ def make_settings_blueprint(config_accessor: ConfigAccessor) -> Blueprint:
         )
 
     @blueprint.route("/strava-callback")
+    @needs_authentication(authenticator)
     def strava_callback():
         code = request.args.get("code", type=str)
         settings_controller.save_strava_code(code)

geo_activity_playground/webui/settings/controller.py

@@ -10,10 +10,32 @@ from geo_activity_playground.core.config import ConfigAccessor
 from geo_activity_playground.core.heart_rate import HeartRateZoneComputer
 
 
+SHAREPIC_FIELDS = {
+    "calories": "Calories",
+    "distance_km": "Distance",
+    "elapsed_time": "Elapsed time",
+    "equipment": "Equipment",
+    "kind": "Kind",
+    "name": "Name",
+    "start": "Date",
+    "Steps": "Steps",
+}
+
+
 class SettingsController:
     def __init__(self, config_accessor: ConfigAccessor) -> None:
         self._config_accessor = config_accessor
 
+    def render_admin_password(self) -> dict:
+        return {
+            "password": self._config_accessor().upload_password,
+        }
+
+    def save_admin_password(self, password: str) -> None:
+        self._config_accessor().upload_password = password
+        self._config_accessor.save()
+        flash("Updated admin password.", category="success")
+
     def render_equipment_offsets(self) -> dict:
         return {
             "equipment_offsets": self._config_accessor().equipment_offsets,
@@ -184,6 +206,27 @@ class SettingsController:
         self._config_accessor.save()
         flash("Updated privacy zones.", category="success")
 
+    def render_sharepic(self) -> dict:
+
+        return {
+            "names": [
+                (
+                    name,
+                    label,
+                    name not in self._config_accessor().sharepic_suppressed_fields,
+                )
+                for name, label in SHAREPIC_FIELDS.items()
+            ]
+        }
+
+    def save_sharepic(self, names: list[str]) -> None:
+        self._config_accessor().sharepic_suppressed_fields = list(
+            set(SHAREPIC_FIELDS) - set(names)
+        )
+        self._config_accessor.save()
+        flash("Updated sharepic preferences.", category="success")
+        pass
+
     def render_strava(self) -> dict:
         return {
             "strava_client_id": self._config_accessor().strava_client_id,

geo_activity_playground/webui/settings/templates/settings/admin-password.html.j2

@@ -0,0 +1,19 @@
+{% extends "page.html.j2" %}
+
+{% block container %}
+
+<h1 class="mb-3">Admin Password</h1>
+
+<p>To protect the settings and the upload functionality, you may specify a password.</p>
+
+<form method="POST">
+    <div class="mb-3">
+        <label for="password" class="form-label">Password</label>
+        <input type="text" class="form-control" id="password" name="password" value="{{ password }}" />
+    </div>
+
+    <button type="submit" class="btn btn-primary">Save</button>
+</form>
+
+
+{% endblock %}

geo_activity_playground/webui/settings/templates/settings/color-schemes.html.j2

@@ -0,0 +1,33 @@
+{% extends "page.html.j2" %}
+
+{% block container %}
+
+<h1 class="mb-3">Color Schemes for Plots</h1>
+
+<p>Don't like color schemes in the plots? Have a look at the <a href="https://vega.github.io/vega/docs/schemes/"
+        target="_blank">colors schemes of Vega</a> and pick one that you like.</p>
+
+<form method="POST">
+    <div class="mb-3">
+        <label class="form-label">Color scheme for activity kinds</label>
+        <select class="form-select" aria-label="Color scheme for activity kinds" name="color_scheme_for_kind">
+            {% for cs in color_scheme_for_kind_avail %}
+            <option {% if cs==color_scheme_for_kind %} selected {% endif %}>{{ cs }}</option>
+            {% endfor %}
+        </select>
+    </div>
+
+    <div class="mb-3">
+        <label class="form-label">Color scheme for heatmaps</label>
+        <select class="form-select" aria-label="Color scheme for heatmaps" name="color_scheme_for_counts">
+            {% for cs in color_scheme_for_counts_avail %}
+            <option {% if cs==color_scheme_for_counts %} selected {% endif %}>{{ cs }}</option>
+            {% endfor %}
+        </select>
+    </div>
+
+    <button type="submit" class="btn btn-primary">Save</button>
+</form>
+
+
+{% endblock %}