geo-activity-playground 1.0.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

geo_activity_playground/webui/blueprints/explorer_blueprint.py

@@ -1,5 +1,6 @@
 import abc
 import datetime
+import hashlib
 import io
 import itertools
 import logging
@@ -21,6 +22,7 @@ from flask import render_template
 from flask import request
 from flask import Response
 from flask import url_for
+from flask.typing import ResponseReturnValue
 
 from ...core.activities import ActivityRepository
 from ...core.config import ConfigAccessor
@@ -62,7 +64,7 @@ class ColorStrategy(abc.ABC):
         pass
 
 
-class ClusterColorStrategy(ColorStrategy):
+class MaxClusterColorStrategy(ColorStrategy):
     def __init__(self, evolution_state, tile_visits):
         self.evolution_state = evolution_state
         self.tile_visits = tile_visits
@@ -84,6 +86,31 @@ class ClusterColorStrategy(ColorStrategy):
             return grayscale
 
 
+class ColorfulClusterColorStrategy(ColorStrategy):
+    def __init__(self, evolution_state: TileEvolutionState, tile_visits):
+        self.evolution_state = evolution_state
+        self.tile_visits = tile_visits
+        self.max_cluster_members = max(
+            evolution_state.clusters.values(),
+            key=len,
+        )
+        self._cmap = matplotlib.colormaps["hsv"]
+
+    def color_image(
+        self, tile_xy: tuple[int, int], grayscale: np.ndarray
+    ) -> np.ndarray:
+        if tile_xy in self.evolution_state.memberships:
+            cluster_id = self.evolution_state.memberships[tile_xy]
+            m = hashlib.sha256()
+            m.update(str(cluster_id).encode())
+            d = int(m.hexdigest(), base=16) / (256.0**m.digest_size)
+            return blend_color(grayscale, np.array([[self._cmap(d)[:3]]]), 0.3)
+        elif tile_xy in self.tile_visits:
+            return blend_color(grayscale, 0.0, 0.3)
+        else:
+            return grayscale
+
+
 class VisitTimeColorStrategy(ColorStrategy):
     def __init__(self, tile_visits, use_first=True):
         self.tile_visits = tile_visits
@@ -133,7 +160,7 @@ def make_explorer_blueprint(
 
     @blueprint.route("/enable-zoom-level/<int:zoom>")
     @needs_authentication(authenticator)
-    def enable_zoom_level(zoom: int):
+    def enable_zoom_level(zoom: int) -> ResponseReturnValue:
         if 0 <= zoom <= 19:
             config_accessor().explorer_zoom_levels.append(zoom)
             config_accessor().explorer_zoom_levels.sort()
@@ -145,11 +172,11 @@ def make_explorer_blueprint(
         return redirect(url_for(".map", zoom=zoom))
 
     @blueprint.route(
-        "/<int:zoom>/<float:north>/<float:east>/<float:south>/<float:west>/explored.<suffix>"
+        "/<int:zoom>/<float:north>/<float:east>/<float:south>/<float:west>/missing.<suffix>"
     )
-    def download(
+    def download_missing(
         zoom: int, north: float, east: float, south: float, west: float, suffix: str
-    ):
+    ) -> ResponseReturnValue:
         x1, y1 = compute_tile(north, west, zoom)
         x2, y2 = compute_tile(south, east, zoom)
         tile_bounds = Bounds(x1, y1, x2 + 2, y2 + 2)
@@ -170,11 +197,11 @@ def make_explorer_blueprint(
         )
 
     @blueprint.route(
-        "/<int:zoom>/<float:north>/<float:east>/<float:south>/<float:west>/missing.<suffix>"
+        "/<int:zoom>/<float:north>/<float:east>/<float:south>/<float:west>/explored.<suffix>"
     )
-    def missing(
+    def download_explored(
         zoom: int, north: float, east: float, south: float, west: float, suffix: str
-    ):
+    ) -> ResponseReturnValue:
         x1, y1 = compute_tile(north, west, zoom)
         x2, y2 = compute_tile(south, east, zoom)
         tile_bounds = Bounds(x1, y1, x2 + 2, y2 + 2)
@@ -197,7 +224,7 @@ def make_explorer_blueprint(
         )
 
     @blueprint.route("/<int:zoom>/server-side")
-    def server_side(zoom: int):
+    def server_side(zoom: int) -> ResponseReturnValue:
         if zoom not in config_accessor().explorer_zoom_levels:
             return {"zoom_level_not_generated": zoom}
 
@@ -239,7 +266,7 @@ def make_explorer_blueprint(
         return render_template("explorer/server-side.html.j2", **context)
 
     @blueprint.route("/<int:zoom>/tile/<int:z>/<int:x>/<int:y>.png")
-    def tile(zoom: int, z: int, x: int, y: int) -> Response:
+    def tile(zoom: int, z: int, x: int, y: int) -> ResponseReturnValue:
         tile_visits = tile_visit_accessor.tile_state["tile_visits"][zoom]
         evolution_state = tile_visit_accessor.tile_state["evolution_state"][zoom]
 
@@ -248,9 +275,16 @@ def make_explorer_blueprint(
         square_line_width = 3
         square_color = np.array([[[228, 26, 28]]]) / 256
 
-        match request.args.get("color_strategy", "cluster"):
-            case "cluster":
-                color_strategy = ClusterColorStrategy(evolution_state, tile_visits)
+        color_strategy_name = request.args.get("color_strategy", "colorful_cluster")
+        if color_strategy_name == "default":
+            color_strategy_name = config_accessor().cluster_color_strategy
+        match color_strategy_name:
+            case "max_cluster":
+                color_strategy = MaxClusterColorStrategy(evolution_state, tile_visits)
+            case "colorful_cluster":
+                color_strategy = ColorfulClusterColorStrategy(
+                    evolution_state, tile_visits
+                )
             case "first":
                 color_strategy = VisitTimeColorStrategy(tile_visits, use_first=True)
             case "last":

geo_activity_playground/webui/blueprints/export_blueprint.py

@@ -2,6 +2,7 @@ from flask import Blueprint
 from flask import render_template
 from flask import request
 from flask import Response
+from flask.typing import ResponseReturnValue
 
 from ...core.export import export_all
 from ..authenticator import Authenticator
@@ -13,12 +14,12 @@ def make_export_blueprint(authenticator: Authenticator) -> Blueprint:
 
     @needs_authentication(authenticator)
     @blueprint.route("/")
-    def index():
+    def index() -> str:
         return render_template("export/index.html.j2")
 
     @needs_authentication(authenticator)
     @blueprint.route("/export")
-    def export():
+    def export() -> Response:
         meta_format = request.args["meta_format"]
         activity_format = request.args["activity_format"]
         return Response(

geo_activity_playground/webui/blueprints/hall_of_fame_blueprint.py

@@ -0,0 +1,79 @@
+import collections
+
+import pandas as pd
+from flask import Blueprint
+from flask import render_template
+from flask import request
+
+from ...core.activities import ActivityRepository
+from ...core.activities import make_geojson_from_time_series
+from ...core.meta_search import apply_search_query
+from ..search_util import search_query_from_form
+from ..search_util import SearchQueryHistory
+
+
+def make_hall_of_fame_blueprint(
+    repository: ActivityRepository,
+    search_query_history: SearchQueryHistory,
+) -> Blueprint:
+    blueprint = Blueprint("hall_of_fame", __name__, template_folder="templates")
+
+    @blueprint.route("/")
+    def index() -> str:
+        query = search_query_from_form(request.args)
+        search_query_history.register_query(query)
+        activities = apply_search_query(repository.meta, query)
+        df = activities
+
+        nominations = nominate_activities(df)
+
+        return render_template(
+            "hall_of_fame/index.html.j2",
+            nominations=[
+                (
+                    repository.get_activity_by_id(activity_id),
+                    reasons,
+                    make_geojson_from_time_series(
+                        repository.get_time_series(activity_id)
+                    ),
+                )
+                for activity_id, reasons in nominations.items()
+            ],
+            query=query.to_jinja(),
+        )
+
+    return blueprint
+
+
+def nominate_activities(meta: pd.DataFrame) -> dict[int, list[str]]:
+    nominations: dict[int, list[str]] = collections.defaultdict(list)
+
+    _nominate_activities_inner(meta, "", nominations)
+
+    for kind, group in meta.groupby("kind"):
+        _nominate_activities_inner(group, f" for {kind}", nominations)
+    for equipment, group in meta.groupby("equipment"):
+        _nominate_activities_inner(group, f" with {equipment}", nominations)
+
+    return nominations
+
+
+def _nominate_activities_inner(
+    meta: pd.DataFrame, title_suffix: str, nominations: dict[int, list[str]]
+) -> None:
+    ratings = [
+        ("distance_km", "Greatest distance", "{:.1f} km"),
+        ("elapsed_time", "Longest elapsed time", "{}"),
+        ("average_speed_moving_kmh", "Highest average moving speed", "{:.1f} km/h"),
+        ("average_speed_elapsed_kmh", "Highest average elapsed speed", "{:.1f} km/h"),
+        ("calories", "Most calories burnt", "{:.0f}"),
+        ("steps", "Most steps", "{:.0f}"),
+        ("elevation_gain", "Largest elevation gain", "{:.0f} m"),
+    ]
+
+    for variable, title, format_str in ratings:
+        if variable in meta.columns and not pd.isna(meta[variable]).all():
+            i = meta[variable].idxmax()
+            value = meta.loc[i, variable]
+            format_applied = format_str.format(value)
+            nominations[i].append(f"{title}{title_suffix}: {format_applied}")

geo_activity_playground/webui/blueprints/photo_blueprint.py

@@ -12,6 +12,7 @@ from flask import render_template
 from flask import request
 from flask import Response
 from flask import url_for
+from flask.typing import ResponseReturnValue
 from PIL import Image
 from PIL import ImageOps
 
@@ -123,7 +124,7 @@ def make_photo_blueprint(
 
     @blueprint.route("/new", methods=["GET", "POST"])
     @needs_authentication(authenticator)
-    def new() -> Response:
+    def new() -> ResponseReturnValue:
         if request.method == "POST":
             # check if the post request has the file part
             if "file" not in request.files:
@@ -132,66 +133,74 @@ def make_photo_blueprint(
                 )
                 return redirect(url_for(".new"))
 
-            file = request.files["file"]
-            # If the user does not select a file, the browser submits an
-            # empty file without a filename.
-            if file.filename == "":
-                flasher.flash_message("No selected file.", FlashTypes.WARNING)
-                return redirect(url_for(".new"))
-            if not file:
-                flasher.flash_message("Empty file uploaded.", FlashTypes.WARNING)
-                return redirect(url_for(".new"))
+            new_photos: list[Photo] = []
+            for file in request.files.getlist("file"):
+                # If the user does not select a file, the browser submits an
+                # empty file without a filename.
+                if file.filename == "":
+                    flasher.flash_message("No selected file.", FlashTypes.WARNING)
+                    return redirect(url_for(".new"))
+                if not file:
+                    flasher.flash_message("Empty file uploaded.", FlashTypes.WARNING)
+                    return redirect(url_for(".new"))
+
+                filename = str(uuid.uuid4()) + pathlib.Path(file.filename).suffix
+                path = PHOTOS_DIR() / "original" / filename
+                path.parent.mkdir(exist_ok=True)
+                file.save(path)
+                metadata = get_metadata_from_image(path)
+
+                if "time" not in metadata:
+                    flasher.flash_message(
+                        f"Your image '{file.filename}' doesn't have the EXIF attribute 'EXIF DateTimeOriginal' and hence cannot be dated.",
+                        FlashTypes.DANGER,
+                    )
+                    continue
+                time: datetime.datetime = metadata["time"]
+
+                activity = DB.session.scalar(
+                    sqlalchemy.select(Activity)
+                    .where(
+                        Activity.start.is_not(None),
+                        Activity.elapsed_time.is_not(None),
+                        Activity.start <= time,
+                    )
+                    .order_by(Activity.start.desc())
+                    .limit(1)
+                )
+                if activity is None or activity.start + activity.elapsed_time < time:
+                    flasher.flash_message(
+                        f"Your image '{file.filename}' is from {time} but no activity could be found. Please first upload an activity or fix the time in the photo.",
+                        FlashTypes.DANGER,
+                    )
+                    continue
+
+                if "latitude" not in metadata:
+                    time_series = activity.time_series
+                    print(time_series)
+                    row = time_series.loc[time_series["time"] >= time].iloc[0]
+                    metadata["latitude"] = row["latitude"]
+                    metadata["longitude"] = row["longitude"]
+
+                photo = Photo(
+                    filename=filename,
+                    time=time,
+                    latitude=metadata["latitude"],
+                    longitude=metadata["longitude"],
+                    activity=activity,
+                )
 
-            filename = str(uuid.uuid4()) + pathlib.Path(file.filename).suffix
-            path = PHOTOS_DIR() / "original" / filename
-            path.parent.mkdir(exist_ok=True)
-            file.save(path)
-            metadata = get_metadata_from_image(path)
+                DB.session.add(photo)
+                DB.session.commit()
+                new_photos.append(photo)
 
-            if "time" not in metadata:
+            if new_photos:
                 flasher.flash_message(
-                    "Your image doesn't have the EXIF attribute 'EXIF DateTimeOriginal' and hence cannot be dated.",
-                    FlashTypes.DANGER,
+                    f"Added {len(new_photos)} new photos.", FlashTypes.SUCCESS
                 )
+                return redirect(f"/activity/{new_photos[-1].activity.id}")
+            else:
                 return redirect(url_for(".new"))
-            time: datetime.datetime = metadata["time"]
-
-            activity = DB.session.scalar(
-                sqlalchemy.select(Activity)
-                .where(
-                    Activity.start.is_not(None),
-                    Activity.elapsed_time.is_not(None),
-                    Activity.start <= time,
-                )
-                .order_by(Activity.start.desc())
-                .limit(1)
-            )
-            if activity is None or activity.start + activity.elapsed_time < time:
-                flasher.flash_message(
-                    f"Your image is from {time} but no activity could be found. Please first upload an activity or fix the time in the photo",
-                    FlashTypes.DANGER,
-                )
-            print(activity)
-
-            if "latitude" not in metadata:
-                time_series = activity.time_series
-                print(time_series)
-                row = time_series.loc[time_series["time"] >= time].iloc[0]
-                metadata["latitude"] = row["latitude"]
-                metadata["longitude"] = row["longitude"]
-
-            photo = Photo(
-                filename=filename,
-                time=time,
-                latitude=metadata["latitude"],
-                longitude=metadata["longitude"],
-                activity=activity,
-            )
-
-            DB.session.add(photo)
-            DB.session.commit()
-
-            return redirect(f"/activity/{activity.id}")
         else:
             return render_template("photo/new.html.j2")
 

geo_activity_playground/webui/blueprints/plot_builder_blueprint.py

@@ -1,3 +1,5 @@
+import json
+
 import sqlalchemy
 from flask import Blueprint
 from flask import redirect
@@ -5,9 +7,12 @@ from flask import render_template
 from flask import request
 from flask import Response
 from flask import url_for
+from flask.typing import ResponseReturnValue
+from flask.typing import RouteCallable
 
 from ...core.activities import ActivityRepository
 from ...core.datamodel import DB
+from ...core.parametric_plot import GROUP_BY_VARIABLES
 from ...core.parametric_plot import make_parametric_plot
 from ...core.parametric_plot import MARKS
 from ...core.parametric_plot import PlotSpec
@@ -25,7 +30,7 @@ def make_plot_builder_blueprint(
     blueprint = Blueprint("plot_builder", __name__, template_folder="templates")
 
     @blueprint.route("/")
-    def index() -> Response:
+    def index() -> ResponseReturnValue:
         return render_template(
             "plot_builder/index.html.j2",
             specs=DB.session.scalars(sqlalchemy.select(PlotSpec)).all(),
@@ -33,7 +38,7 @@ def make_plot_builder_blueprint(
 
     @blueprint.route("/new")
     @needs_authentication(authenticator)
-    def new() -> Response:
+    def new() -> ResponseReturnValue:
         spec = PlotSpec(
             name="My New Plot",
             mark="bar",
@@ -45,23 +50,36 @@ def make_plot_builder_blueprint(
         DB.session.commit()
         return redirect(url_for(".edit", id=spec.id))
 
-    @blueprint.route("/edit/<int:id>")
+    @blueprint.route("/import-spec", methods=["GET", "POST"])
     @needs_authentication(authenticator)
-    def edit(id: int) -> Response:
-        spec = DB.session.get(PlotSpec, id)
-        if request.args:
-            spec.name = request.args["name"]
-            spec.mark = request.args["mark"]
-            spec.x = request.args["x"]
-            spec.y = request.args["y"]
-            spec.color = request.args["color"]
-            spec.shape = request.args["shape"]
-            spec.size = request.args["size"]
-            spec.size = request.args["size"]
-            spec.row = request.args["row"]
-            spec.column = request.args["column"]
-            spec.facet = request.args["facet"]
-            spec.opacity = request.args["opacity"]
+    def import_spec() -> ResponseReturnValue:
+        if request.form:
+            parameters = json.loads(request.form["spec_json"])
+            spec = PlotSpec(**parameters)
+            DB.session.add(spec)
+            DB.session.commit()
+            return redirect(url_for(".edit", id=spec.id))
+        else:
+            return render_template("plot_builder/import-spec.html.j2")
+
+    @blueprint.route("/edit/<int:id>", methods=["GET", "POST"])
+    @needs_authentication(authenticator)
+    def edit(id: int) -> ResponseReturnValue:
+        spec = DB.session.get_one(PlotSpec, id)
+        if request.form:
+            spec.name = request.form["name"]
+            spec.mark = request.form["mark"]
+            spec.x = request.form["x"]
+            spec.y = request.form["y"]
+            spec.color = request.form["color"]
+            spec.shape = request.form["shape"]
+            spec.size = request.form["size"]
+            spec.size = request.form["size"]
+            spec.row = request.form["row"]
+            spec.column = request.form["column"]
+            spec.facet = request.form["facet"]
+            spec.opacity = request.form["opacity"]
+            spec.group_by = request.form["group_by"]
         try:
             plot = make_parametric_plot(repository.meta, spec)
             DB.session.commit()
@@ -73,13 +91,14 @@ def make_plot_builder_blueprint(
             marks=MARKS,
             discrete=VARIABLES_1,
             continuous=VARIABLES_2,
+            group_by=GROUP_BY_VARIABLES,
             plot=plot,
             spec=spec,
         )
 
     @blueprint.route("/delete/<int:id>")
     @needs_authentication(authenticator)
-    def delete(id: int) -> Response:
+    def delete(id: int) -> ResponseReturnValue:
         spec = DB.session.get(PlotSpec, id)
         DB.session.delete(spec)
         flasher.flash_message(f"Deleted plot '{spec.name}'.", FlashTypes.SUCCESS)

geo_activity_playground/webui/blueprints/settings_blueprint.py

@@ -447,6 +447,23 @@ def make_settings_blueprint(
         else:
             return render_template("settings/tags-edit.html.j2", tag=tag)
 
+    @blueprint.route("/tile-source", methods=["GET", "POST"])
+    @needs_authentication(authenticator)
+    def tile_source() -> str:
+        if request.method == "POST":
+            config_accessor().map_tile_url = request.form["map_tile_url"]
+            config_accessor().map_tile_attribution = request.form[
+                "map_tile_attribution"
+            ]
+            config_accessor.save()
+            flasher.flash_message("Tile source updated.", FlashTypes.SUCCESS)
+        return render_template(
+            "settings/tile-source.html.j2",
+            map_tile_url=config_accessor().map_tile_url,
+            map_tile_attribution=config_accessor().map_tile_attribution,
+            test_url=config_accessor().map_tile_url.format(zoom=14, x=8514, y=5504),
+        )
+
     return blueprint