geo-activity-playground 0.36.2__py3-none-any.whl → 0.38.0__py3-none-any.whl

geo_activity_playground/webui/heatmap/heatmap_controller.py

@@ -11,6 +11,8 @@ from PIL import ImageDraw
 
 from geo_activity_playground.core.activities import ActivityRepository
 from geo_activity_playground.core.config import Config
+from geo_activity_playground.core.meta_search import apply_search_query
+from geo_activity_playground.core.meta_search import SearchQuery
 from geo_activity_playground.core.raster_map import convert_to_grayscale
 from geo_activity_playground.core.raster_map import GeoBounds
 from geo_activity_playground.core.raster_map import get_sensible_zoom_level
@@ -48,12 +50,7 @@ class HeatmapController:
             "activities_per_tile"
         ]
 
-    def render(
-        self,
-        kinds: list[int],
-        date_start: Optional[datetime.date],
-        date_end: Optional[datetime.date],
-    ) -> dict:
+    def render(self, query: SearchQuery) -> dict:
         zoom = 14
         tiles = self.tile_histories[zoom]
         medians = tiles.median(skipna=True)
@@ -62,19 +59,6 @@ class HeatmapController:
         )
         cluster_state = self.tile_evolution_states[zoom]
 
-        available_kinds = sorted(self._repository.meta["kind"].unique())
-
-        if not kinds:
-            kinds = list(range(len(available_kinds)))
-
-        extra_args = []
-        if date_start is not None:
-            extra_args.append(f"date-start={date_start.isoformat()}")
-        if date_end is not None:
-            extra_args.append(f"date-end={date_end.isoformat()}")
-        for kind in kinds:
-            extra_args.append(f"kind={kind}")
-
         values = {
             "center": {
                 "latitude": median_lat,
@@ -87,14 +71,9 @@ class HeatmapController:
                     else {}
                 ),
             },
-            "kinds": kinds,
-            "available_kinds": available_kinds,
-            "extra_args": "&".join(extra_args),
+            "extra_args": query.to_url_str(),
+            "query": query.to_jinja(),
         }
-        if date_start is not None:
-            values["date_start"] = date_start.date().isoformat()
-        if date_end is not None:
-            values["date_end"] = date_end.date().isoformat()
 
         return values
 
@@ -103,16 +82,12 @@ class HeatmapController:
         x: int,
         y: int,
         z: int,
-        kind: str,
-        date_start: Optional[datetime.date],
-        date_end: Optional[datetime.date],
+        query: SearchQuery,
     ) -> np.ndarray:
         tile_pixels = (OSM_TILE_SIZE, OSM_TILE_SIZE)
         tile_counts = np.zeros(tile_pixels, dtype=np.int32)
-        if date_start is None and date_end is None:
-            tile_count_cache_path = pathlib.Path(
-                f"Cache/Heatmap/{kind}/{z}/{x}/{y}.npy"
-            )
+        if not query.active:
+            tile_count_cache_path = pathlib.Path(f"Cache/Heatmap/{z}/{x}/{y}.npy")
             if tile_count_cache_path.exists():
                 try:
                     tile_counts = np.load(tile_count_cache_path)
@@ -124,52 +99,41 @@ class HeatmapController:
                     tile_counts = np.zeros(tile_pixels, dtype=np.int32)
             tile_count_cache_path.parent.mkdir(parents=True, exist_ok=True)
             activity_ids = self.activities_per_tile[z].get((x, y), set())
-            activity_ids_kind = set()
-            for activity_id in activity_ids:
-                activity = self._repository.get_activity_by_id(activity_id)
-                if activity["kind"] == kind:
-                    activity_ids_kind.add(activity_id)
-            if activity_ids_kind:
-                with work_tracker(
-                    tile_count_cache_path.with_suffix(".json")
-                ) as parsed_activities:
-                    if parsed_activities - activity_ids_kind:
-                        logger.warning(
-                            f"Resetting heatmap cache for {kind=}/{x=}/{y=}/{z=} because activities have been removed."
+
+            with work_tracker(
+                tile_count_cache_path.with_suffix(".json")
+            ) as parsed_activities:
+                if parsed_activities - activity_ids:
+                    logger.warning(
+                        f"Resetting heatmap cache for {x=}/{y=}/{z=} because activities have been removed."
+                    )
+                    tile_counts = np.zeros(tile_pixels, dtype=np.int32)
+                    parsed_activities.clear()
+                for activity_id in activity_ids:
+                    if activity_id in parsed_activities:
+                        continue
+                    parsed_activities.add(activity_id)
+                    time_series = self._repository.get_time_series(activity_id)
+                    for _, group in time_series.groupby("segment_id"):
+                        xy_pixels = (
+                            np.array([group["x"] * 2**z - x, group["y"] * 2**z - y]).T
+                            * OSM_TILE_SIZE
                         )
-                        tile_counts = np.zeros(tile_pixels, dtype=np.int32)
-                        parsed_activities.clear()
-                    for activity_id in activity_ids_kind:
-                        if activity_id in parsed_activities:
-                            continue
-                        parsed_activities.add(activity_id)
-                        time_series = self._repository.get_time_series(activity_id)
-                        for _, group in time_series.groupby("segment_id"):
-                            xy_pixels = (
-                                np.array(
-                                    [group["x"] * 2**z - x, group["y"] * 2**z - y]
-                                ).T
-                                * OSM_TILE_SIZE
-                            )
-                            im = Image.new("L", tile_pixels)
-                            draw = ImageDraw.Draw(im)
-                            pixels = list(map(int, xy_pixels.flatten()))
-                            draw.line(pixels, fill=1, width=max(3, 6 * (z - 17)))
-                            aim = np.array(im)
-                            tile_counts += aim
-                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)
+                        im = Image.new("L", tile_pixels)
+                        draw = ImageDraw.Draw(im)
+                        pixels = list(map(int, xy_pixels.flatten()))
+                        draw.line(pixels, fill=1, width=max(3, 6 * (z - 17)))
+                        aim = np.array(im)
+                        tile_counts += aim
+            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)
         else:
+            activities = apply_search_query(self._repository.meta, query)
             activity_ids = self.activities_per_tile[z].get((x, y), set())
             for activity_id in activity_ids:
-                activity = self._repository.get_activity_by_id(activity_id)
-                if not activity["kind"] == kind:
-                    continue
-                if date_start is not None and activity["start"] < date_start:
-                    continue
-                if date_end is not None and date_end < activity["start"]:
+                if activity_id not in activities["id"]:
                     continue
                 time_series = self._repository.get_time_series(activity_id)
                 for _, group in time_series.groupby("segment_id"):
@@ -190,16 +154,11 @@ class HeatmapController:
         x: int,
         y: int,
         z: int,
-        kinds_ids: list[int],
-        date_start: Optional[datetime.date],
-        date_end: Optional[datetime.date],
+        query: SearchQuery,
     ) -> np.ndarray:
         tile_pixels = (OSM_TILE_SIZE, OSM_TILE_SIZE)
         tile_counts = np.zeros(tile_pixels)
-        available_kinds = sorted(self._repository.meta["kind"].unique())
-        for kind_id in kinds_ids:
-            kind = available_kinds[kind_id]
-            tile_counts += self._get_counts(x, y, z, kind, date_start, date_end)
+        tile_counts += self._get_counts(x, y, z, query)
 
         tile_counts = np.sqrt(tile_counts) / 5
         tile_counts[tile_counts > 1.0] = 1.0
@@ -217,32 +176,17 @@ class HeatmapController:
             ] + data_color[:, :, c]
         return map_tile
 
-    def render_tile(
-        self,
-        x: int,
-        y: int,
-        z: int,
-        kind_ids: list[int],
-        date_start: Optional[datetime.date],
-        date_end: Optional[datetime.date],
-    ) -> bytes:
+    def render_tile(self, x: int, y: int, z: int, query: SearchQuery) -> bytes:
         f = io.BytesIO()
         pl.imsave(
             f,
-            self._render_tile_image(x, y, z, kind_ids, date_start, date_end),
+            self._render_tile_image(x, y, z, query),
             format="png",
         )
         return bytes(f.getbuffer())
 
     def download_heatmap(
-        self,
-        north: float,
-        east: float,
-        south: float,
-        west: float,
-        kind_ids: list[int],
-        date_start: Optional[datetime.date],
-        date_end: Optional[datetime.date],
+        self, north: float, east: float, south: float, west: float, query: SearchQuery
     ) -> bytes:
         geo_bounds = GeoBounds(south, west, north, east)
         tile_bounds = get_sensible_zoom_level(geo_bounds, (4000, 4000))
@@ -265,9 +209,7 @@ class HeatmapController:
                     i * OSM_TILE_SIZE : (i + 1) * OSM_TILE_SIZE,
                     j * OSM_TILE_SIZE : (j + 1) * OSM_TILE_SIZE,
                     :,
-                ] = self._render_tile_image(
-                    x, y, tile_bounds.zoom, kind_ids, date_start, date_end
-                )
+                ] = self._render_tile_image(x, y, tile_bounds.zoom, query)
 
         f = io.BytesIO()
         pl.imsave(f, background, format="png")

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

@@ -1,44 +1,12 @@
 {% extends "page.html.j2" %}
+{% from "search_form.html.j2" import search_form %}
 
 {% block container %}
-<div class="row mb-3">
-    <div class="col">
-        <h1>Heatmap</h1>
-    </div>
-</div>
-
-<form action="" method="GET">
-
-    <div class="row mb-3">
-        <label class="col-sm-2 col-form-label">Kinds</label>
+<h1 class="mb-3">Heatmap</h1>
 
-        <div class="col-sm-10">
-            {% for kind in available_kinds %}
-            <div class="form-check form-check-inline form-switch ">
-                <input class="form-check-input" type="checkbox" role="switch" id="kind{{ loop.index0 }}" name="kind"
-                    value="{{ loop.index0 }}" {{ 'checked' if loop.index0 in kinds else '' }} />
-                <label class="form-check-label" for="kind{{ loop.index0 }}">{{ kind }}</label>
-            </div>
-            {% endfor %}
-        </div>
-    </div>
-
-    <div class="row mb-3">
-        <label class="col-sm-2 col-form-label">Date range</label>
-        <div class="col-sm-5">
-            <input type="date" id="date-start" name="date-start" value="{{ date_start }}" />
-            <label for="date-start" class="form-label">Start date</label>
-        </div>
-        <div class="col-sm-5">
-            <input type="date" id="date-end" name="date-end" value="{{ date_end }}" />
-            <label for="date-start" class="form-label">End date</label>
-        </div>
-    </div>
-
-    <div class="mb-3">
-        <button type="submit" class="btn btn-primary">Filter heatmap</button>
-    </div>
-</form>
+<div class="mb-3">
+    {{ search_form(query, equipments_avail, kinds_avail, search_query_favorites, search_query_last, request_url) }}
+</div>
 
 <div class="row mb-3">
     <div class="col">

geo_activity_playground/webui/search_blueprint.py

@@ -1,13 +1,22 @@
+import urllib.parse
 from functools import reduce
 
 import dateutil.parser
 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 ..core.activities import ActivityRepository
+from geo_activity_playground.core.config import ConfigAccessor
+from geo_activity_playground.core.meta_search import apply_search_query
+from geo_activity_playground.core.meta_search import SearchQuery
+from geo_activity_playground.webui.authenticator import Authenticator
+from geo_activity_playground.webui.authenticator import needs_authentication
+from geo_activity_playground.webui.search_util import search_query_from_form
+from geo_activity_playground.webui.search_util import SearchQueryHistory
 
 
 def reduce_or(selections):
@@ -18,84 +27,44 @@ def reduce_and(selections):
     return reduce(lambda a, b: a & b, selections)
 
 
-def make_search_blueprint(repository: ActivityRepository) -> Blueprint:
+def make_search_blueprint(
+    repository: ActivityRepository,
+    search_query_history: SearchQueryHistory,
+    authenticator: Authenticator,
+    config_accessor: ConfigAccessor,
+) -> Blueprint:
     blueprint = Blueprint("search", __name__, template_folder="templates")
 
     @blueprint.route("/")
     def index():
-        kinds_avail = repository.meta["kind"].unique()
-        equipments_avail = repository.meta["equipment"].unique()
-
-        print(request.args)
-
-        activities = repository.meta
-
-        if equipments := request.args.getlist("equipment"):
-            selection = reduce_or(
-                activities["equipment"] == equipment for equipment in equipments
-            )
-            activities = activities.loc[selection]
-
-        if kinds := request.args.getlist("kind"):
-            selection = reduce_or(activities["kind"] == kind for kind in kinds)
-            activities = activities.loc[selection]
-
-        name_exact = bool(request.args.get("name_exact", False))
-        name_casing = bool(request.args.get("name_casing", False))
-        if name := request.args.get("name", ""):
-            if name_casing:
-                haystack = activities["name"]
-                needle = name
-            else:
-                haystack = activities["name"].str.lower()
-                needle = name.lower()
-            if name_exact:
-                selection = haystack == needle
-            else:
-                selection = [needle in an for an in haystack]
-            activities = activities.loc[selection]
-
-        begin = request.args.get("begin", "")
-        end = request.args.get("end", "")
-
-        if begin:
-            try:
-                begin_dt = dateutil.parser.parse(begin)
-            except ValueError:
-                flash(
-                    f"Cannot parse date `{begin}`, please use a different format.",
-                    category="danger",
-                )
-            else:
-                selection = begin_dt <= activities["start"]
-                activities = activities.loc[selection]
-
-        if end:
-            try:
-                end_dt = dateutil.parser.parse(end)
-            except ValueError:
-                flash(
-                    f"Cannot parse date `{end}`, please use a different format.",
-                    category="danger",
-                )
-            else:
-                selection = activities["start"] < end_dt
-                activities = activities.loc[selection]
-
-        activities = activities.sort_values("start", ascending=False)
+        query = search_query_from_form(request.args)
+        search_query_history.register_query(query)
+        activities = apply_search_query(repository.meta, query)
 
         return render_template(
             "search/index.html.j2",
-            activities=list(activities.iterrows()),
-            equipments=request.args.getlist("equipment"),
-            equipments_avail=sorted(equipments_avail),
-            kinds=request.args.getlist("kind"),
-            kinds_avail=sorted(kinds_avail),
-            name=name,
-            name_exact=name_exact,
-            name_casing=name_casing,
-            begin=begin,
-            end=end,
+            activities=reversed(list(activities.iterrows())),
+            query=query.to_jinja(),
         )
 
+    @blueprint.route("/save-search-query")
+    @needs_authentication(authenticator)
+    def save_search_query():
+        query = search_query_from_form(request.args)
+        primitives = query.to_primitives()
+        if primitives not in config_accessor().search_queries_favorites:
+            config_accessor().search_queries_favorites.append(primitives)
+            config_accessor.save()
+        return redirect(urllib.parse.unquote_plus(request.args["redirect"]))
+
+    @blueprint.route("/delete-search-query")
+    @needs_authentication(authenticator)
+    def delete_search_query():
+        query = search_query_from_form(request.args)
+        primitives = query.to_primitives()
+        if primitives in config_accessor().search_queries_favorites:
+            config_accessor().search_queries_favorites.remove(primitives)
+            config_accessor.save()
+        return redirect(urllib.parse.unquote_plus(request.args["redirect"]))
+
     return blueprint

geo_activity_playground/webui/search_util.py

@@ -0,0 +1,64 @@
+from typing import Optional
+
+from werkzeug.datastructures import MultiDict
+
+from geo_activity_playground.core.config import ConfigAccessor
+from geo_activity_playground.core.meta_search import _parse_date_or_none
+from geo_activity_playground.core.meta_search import SearchQuery
+from geo_activity_playground.webui.authenticator import Authenticator
+
+
+def search_query_from_form(args: MultiDict) -> SearchQuery:
+    query = SearchQuery(
+        equipment=args.getlist("equipment"),
+        kind=args.getlist("kind"),
+        name=args.get("name", None),
+        name_case_sensitive=_parse_bool(args.get("name_case_sensitive", "false")),
+        start_begin=_parse_date_or_none(args.get("start_begin", None)),
+        start_end=_parse_date_or_none(args.get("start_end", None)),
+    )
+
+    return query
+
+
+def _parse_bool(s: str) -> bool:
+    return s == "true"
+
+
+class SearchQueryHistory:
+    def __init__(
+        self, config_accessor: ConfigAccessor, authenticator: Authenticator
+    ) -> None:
+        self._config_accessor = config_accessor
+        self._authenticator = authenticator
+
+    def register_query(self, search_query: SearchQuery) -> None:
+        if not self._authenticator.is_authenticated():
+            return
+
+        if not search_query.active:
+            return
+
+        primitives = search_query.to_primitives()
+        while primitives in self._config_accessor().search_queries_last:
+            self._config_accessor().search_queries_last.remove(primitives)
+        self._config_accessor().search_queries_last.append(primitives)
+        while (
+            len(self._config_accessor().search_queries_last)
+            > self._config_accessor().search_queries_num_keep
+        ):
+            self._config_accessor().search_queries_last.pop(0)
+        self._config_accessor.save()
+
+    def prepare_favorites(self) -> list[dict]:
+        return self._prepare_list(self._config_accessor().search_queries_favorites)
+
+    def prepare_last(self) -> list[dict]:
+        return self._prepare_list(self._config_accessor().search_queries_last)
+
+    def _prepare_list(self, l: list[dict]) -> list[tuple[str, dict]]:
+        result = []
+        for elem in l:
+            search_query = SearchQuery.from_primitives(elem)
+            result.append((str(search_query), search_query.to_url_str()))
+        return result

geo_activity_playground/webui/summary_blueprint.py

@@ -5,20 +5,32 @@ import altair as alt
 import pandas as pd
 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
 
 
-def make_summary_blueprint(repository: ActivityRepository, config: Config) -> Blueprint:
+def make_summary_blueprint(
+    repository: ActivityRepository,
+    config: Config,
+    search_query_history: SearchQueryHistory,
+) -> Blueprint:
     blueprint = Blueprint("summary", __name__, template_folder="templates")
 
     @blueprint.route("/")
     def index():
+        query = search_query_from_form(request.args)
+        search_query_history.register_query(query)
+        activities = apply_search_query(repository.meta, query)
+
         kind_scale = make_kind_scale(repository.meta, config)
-        df = embellished_activities(repository.meta)
+        df = embellished_activities(activities)
         # df = df.loc[df["consider_for_achievements"]]
 
         year_kind_total = (
@@ -46,8 +58,9 @@ def make_summary_blueprint(repository: ActivityRepository, config: Config) -> Bl
                         repository.get_time_series(activity_id)
                     ),
                 )
-                for activity_id, reasons in nominate_activities(repository.meta).items()
+                for activity_id, reasons in nominate_activities(df).items()
             ],
+            query=query.to_jinja(),
         )
 
     return blueprint
@@ -56,46 +69,35 @@ def make_summary_blueprint(repository: ActivityRepository, config: Config) -> Bl
 def nominate_activities(meta: pd.DataFrame) -> dict[int, list[str]]:
     nominations: dict[int, list[str]] = collections.defaultdict(list)
 
-    subset = meta.loc[meta["consider_for_achievements"]]
-
-    i = subset["distance_km"].idxmax()
-    nominations[i].append(f"Greatest distance: {meta.loc[i].distance_km:.1f} km")
+    _nominate_activities_inner(meta, "", nominations)
 
-    i = subset["elapsed_time"].idxmax()
-    nominations[i].append(f"Longest elapsed time: {meta.loc[i].elapsed_time}")
+    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)
 
-    if "calories" in subset.columns and not pd.isna(subset["calories"]).all():
-        i = subset["calories"].idxmax()
-        nominations[i].append(f"Most calories burnt: {meta.loc[i].calories:.0f} kcal")
+    return nominations
 
-    if "steps" in subset.columns and not pd.isna(subset["steps"]).all():
-        i = subset["steps"].idxmax()
-        nominations[i].append(f"Most steps: {meta.loc[i].steps:.0f}")
 
-    for kind, group in meta.groupby("kind"):
-        for key, text in [
-            (
-                "distance_km",
-                lambda row: f"Greatest distance for {row.kind}: {row.distance_km:.1f} km",
-            ),
-            (
-                "elapsed_time",
-                lambda row: f"Longest elapsed time for {row.kind}: {row.elapsed_time}",
-            ),
-            (
-                "calories",
-                lambda row: f"Most calories burnt for {row.kind}: {row.calories:.0f} kcal",
-            ),
-            ("steps", lambda row: f"Most steps for {row.kind}: {row.steps:.0f}"),
-        ]:
-            if key in group.columns:
-                series = group[key]
-                if not pd.isna(series).all():
-                    i = series.idxmax()
-                    if not pd.isna(i):
-                        nominations[i].append(text(meta.loc[i]))
+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"),
+    ]
 
-    return nominations
+    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}")
 
 
 def embellished_activities(meta: pd.DataFrame) -> pd.DataFrame:
@@ -108,7 +110,6 @@ def embellished_activities(meta: pd.DataFrame) -> pd.DataFrame:
     df["hours"] = [
         elapsed_time.total_seconds() / 3600 for elapsed_time in df["elapsed_time"]
     ]
-    del df["elapsed_time"]
     return df