geo-activity-playground 0.38.1__py3-none-any.whl → 0.39.0__py3-none-any.whl

geo_activity_playground/webui/settings/blueprint.py

@@ -1,262 +0,0 @@
-import shutil
-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.core.paths import _activity_enriched_dir
-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
-
-
-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",
-]
-
-
-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
-) -> 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().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("/equipment-offsets", methods=["GET", "POST"])
-    @needs_authentication(authenticator)
-    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"])
-    @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"])
-            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("/kind-renames", methods=["GET", "POST"])
-    @needs_authentication(authenticator)
-    def kind_renames():
-        if request.method == "POST":
-            rules_str = request.form["rules_str"]
-            rules = {}
-            try:
-                for line in rules_str.strip().split("\n"):
-                    first, second = line.split(" => ")
-                    rules[first.strip()] = second.strip()
-                config_accessor().kind_renames = rules
-                config_accessor.save()
-                flash(f"Kind renames updated.", category="success")
-                shutil.rmtree(_activity_enriched_dir)
-                return redirect(url_for("upload.reload"))
-            except ValueError as e:
-                flash(f"Cannot parse this. Please try again.", category="danger")
-        else:
-            rules_str = "\n".join(
-                f"{key} => {value}"
-                for key, value in config_accessor().kind_renames.items()
-            )
-        return render_template(
-            "settings/kind-renames.html.j2",
-            rules_str=rules_str,
-        )
-
-    @blueprint.route("/kinds-without-achievements", methods=["GET", "POST"])
-    @needs_authentication(authenticator)
-    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"])
-    @needs_authentication(authenticator)
-    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"])
-    @needs_authentication(authenticator)
-    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("/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")
-            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"]
-            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")
-    @needs_authentication(authenticator)
-    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

@@ -1,272 +0,0 @@
-import json
-import re
-import urllib.parse
-from typing import Any
-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
-
-
-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,
-        }
-
-    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: dict[str, Any] = {
-            "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 or 0
-        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_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,
-            "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")
-
-
-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

@@ -1,44 +0,0 @@
-{% 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/kind-renames.html.j2

@@ -1,25 +0,0 @@
-{% extends "page.html.j2" %}
-
-{% block container %}
-
-<h1 class="mb-3">Kind renaming</h1>
-
-<p>If you have used different apps for tracking, you might have that your bike rides have <i>kind</i> "ride", "Ride",
-    "Radfahrt" and so on. In order to unify these, you can specify mappings from old to new names.</p>
-
-<p>If you want to unify these to "Ride", enter the following:</p>
-
-<pre><code>
-ride =&gt; Ride
-Radfahrt =&gt; Ride
-</code></pre>
-
-<form method="POST">
-    <div class="mb-3">
-        <label for="rules" class="form-label">Rules</label>
-        <textarea class="form-control" id=rules" cols="80" rows="10" name="rules_str">{{ rules_str }}</textarea>
-    </div>
-    <button type="submit" class="btn btn-primary">Save</button>
-</form>
-
-{% endblock %}

geo_activity_playground/webui/settings/templates/settings/kinds-without-achievements.html.j2

@@ -1,30 +0,0 @@
-{% extends "page.html.j2" %}
-
-{% block container %}
-
-<h1 class="mb-3">Kinds without Achievements</h1>
-
-<p>Apart from bicycle rides and runs, you might also record your car and train rides. If you don't want to include these
-    for achievements like explorer tiles, you can enter the activity kinds that should not be considered here.</p>
-
-<form method="POST">
-    <div class="row">
-        <div class="col-md-6">
-            {% for kind in kinds_without_achievements %}
-            <div class="mb-3">
-                <label for="kind_{{ loop.index }}" class="form-label">Kind</label>
-                <input type="text" class="form-control" id="kind_{{ loop.index }}" name="kind" value="{{ kind }}" />
-            </div>
-            {% endfor %}
-            <div class="mb-3">
-                <label for="regex_new" class="form-label">Kind</label>
-                <input type="text" class="form-control" id="kind_new" name="kind" />
-            </div>
-        </div>
-    </div>
-
-    <button type="submit" class="btn btn-primary">Save</button>
-</form>
-
-
-{% endblock %}

geo_activity_playground/webui/tile_blueprint.py

@@ -1,42 +0,0 @@
-import io
-
-import matplotlib.pyplot as pl
-import numpy as np
-from flask import Blueprint
-from flask import Response
-
-from geo_activity_playground.core.config import Config
-from geo_activity_playground.core.raster_map import get_tile
-
-
-def make_tile_blueprint(config: Config) -> Blueprint:
-    blueprint = Blueprint("tiles", __name__, template_folder="templates")
-
-    @blueprint.route("/color/<int:z>/<int:x>/<int:y>.png")
-    def tile_color(x: int, y: int, z: int):
-        map_tile = np.array(get_tile(z, x, y, config.map_tile_url)) / 255
-        f = io.BytesIO()
-        pl.imsave(f, map_tile, format="png")
-        return Response(bytes(f.getbuffer()), mimetype="image/png")
-
-    @blueprint.route("/grayscale/<int:z>/<int:x>/<int:y>.png")
-    def tile_grayscale(x: int, y: int, z: int):
-        map_tile = np.array(get_tile(z, x, y, config.map_tile_url)) / 255
-        map_tile = np.sum(map_tile * [0.2126, 0.7152, 0.0722], axis=2)  # to grayscale
-        map_tile = np.dstack((map_tile, map_tile, map_tile))  # to rgb
-        f = io.BytesIO()
-        pl.imsave(f, map_tile, format="png")
-        return Response(bytes(f.getbuffer()), mimetype="image/png")
-
-    @blueprint.route("/pastel/<int:z>/<int:x>/<int:y>.png")
-    def tile_pastel(x: int, y: int, z: int):
-        map_tile = np.array(get_tile(z, x, y, config.map_tile_url)) / 255
-        averaged_tile = np.sum(map_tile * [0.2126, 0.7152, 0.0722], axis=2)
-        grayscale_tile = np.dstack((averaged_tile, averaged_tile, averaged_tile))
-        factor = 0.7
-        pastel_tile = factor * grayscale_tile + (1 - factor) * map_tile
-        f = io.BytesIO()
-        pl.imsave(f, pastel_tile, format="png")
-        return Response(bytes(f.getbuffer()), mimetype="image/png")
-
-    return blueprint