geo-activity-playground 0.36.1__py3-none-any.whl → 0.37.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) }}
+</div>
 
 <div class="row mb-3">
     <div class="col">

geo_activity_playground/webui/search_blueprint.py

@@ -8,6 +8,9 @@ from flask import request
 from flask import Response
 
 from ..core.activities import ActivityRepository
+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.search_util import search_query_from_form
 
 
 def reduce_or(selections):
@@ -23,79 +26,13 @@ def make_search_blueprint(repository: ActivityRepository) -> Blueprint:
 
     @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)
+        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,
+            query=query.to_jinja(),
         )
 
     return blueprint

geo_activity_playground/webui/search_util.py

@@ -0,0 +1,31 @@
+import datetime
+from typing import Optional
+
+import dateutil.parser
+from werkzeug.datastructures import MultiDict
+
+from geo_activity_playground.core.meta_search import SearchQuery
+
+
+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_date_or_none(s: Optional[str]) -> Optional[datetime.date]:
+    if not s:
+        return None
+    else:
+        return dateutil.parser.parse(s).date()
+
+
+def _parse_bool(s: str) -> bool:
+    return s == "true"

geo_activity_playground/webui/summary_blueprint.py

@@ -5,11 +5,14 @@ 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
 
 
 def make_summary_blueprint(repository: ActivityRepository, config: Config) -> Blueprint:
@@ -17,8 +20,11 @@ def make_summary_blueprint(repository: ActivityRepository, config: Config) -> Bl
 
     @blueprint.route("/")
     def index():
+        query = search_query_from_form(request.args)
+        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 +52,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,20 +63,18 @@ 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()
+    i = meta["distance_km"].idxmax()
     nominations[i].append(f"Greatest distance: {meta.loc[i].distance_km:.1f} km")
 
-    i = subset["elapsed_time"].idxmax()
+    i = meta["elapsed_time"].idxmax()
     nominations[i].append(f"Longest elapsed time: {meta.loc[i].elapsed_time}")
 
-    if "calories" in subset.columns and not pd.isna(subset["calories"]).all():
-        i = subset["calories"].idxmax()
+    if "calories" in meta.columns and not pd.isna(meta["calories"]).all():
+        i = meta["calories"].idxmax()
         nominations[i].append(f"Most calories burnt: {meta.loc[i].calories:.0f} kcal")
 
-    if "steps" in subset.columns and not pd.isna(subset["steps"]).all():
-        i = subset["steps"].idxmax()
+    if "steps" in meta.columns and not pd.isna(meta["steps"]).all():
+        i = meta["steps"].idxmax()
         nominations[i].append(f"Most steps: {meta.loc[i].steps:.0f}")
 
     for kind, group in meta.groupby("kind"):
@@ -108,7 +113,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
 
 

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

@@ -1,8 +1,13 @@
 {% extends "page.html.j2" %}
+{% from "search_form.html.j2" import search_form %}
 
 {% block container %}
 <h1 class="mb-3">Eddington Number</h1>
 
+<div class="mb-3">
+    {{ search_form(query, equipments_avail, kinds_avail) }}
+</div>
+
 <div class="row mb-3">
     <div class="col-md-4">
         <h2>Definition</h2>

geo_activity_playground/webui/{equipment/templates → templates}/equipment/index.html.j2

@@ -13,7 +13,6 @@
             <thead>
                 <tr>
                     <th>Equipment</th>
-                    <th>Primarily used for</th>
                     <th style="text-align: right;">Distance / km</th>
                     <th style="text-align: right;">First use</th>
                     <th style="text-align: right;">Last use</th>
@@ -23,10 +22,9 @@
                 {% for equipment in equipment_summary %}
                 <tr>
                     <td>{{ equipment.equipment }}</td>
-                    <td>{{ equipment.primarily_used_for }}</td>
-                    <td style="text-align: right;">{{ equipment.total_distance_km|int }}</td>
-                    <td style="text-align: right;">{{ equipment.first_use.date() }}</td>
-                    <td style="text-align: right;">{{ equipment.last_use.date() }}</td>
+                    <td style="text-align: right;">{{ equipment.total_distance_km }}</td>
+                    <td style="text-align: right;">{{ equipment.first_use }}</td>
+                    <td style="text-align: right;">{{ equipment.last_use }}</td>
                 </tr>
                 {% endfor %}
             </tbody>

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

@@ -1,91 +1,38 @@
 {% extends "page.html.j2" %}
+{% from "search_form.html.j2" import search_form %}
 
 {% block container %}
 
 <h1 class="row mb-3">Activities Overview & Search</h1>
 
-<div class="row mb-3">
-    <div class="col-md-2">
-        <form>
-            <div class="mb-3">
-                <label for="name" class="form-label">Name</label>
-                <input type="text" class="form-control" id="name" name="name" value="{{ name }}">
-                <div class="form-check">
-                    <input class="form-check-input" type="checkbox" name="name_exact" value="true" id="name_exact" {% if
-                        name_exact %} checked {% endif %}>
-                    <label class="form-check-label" for="name_exact">
-                        Exact match
-                    </label>
-                </div>
-                <div class="form-check">
-                    <input class="form-check-input" type="checkbox" name="name_casing" value="true" id="name_casing" {%
-                        if name_casing %} checked {% endif %}>
-                    <label class="form-check-label" for="name_casing">
-                        Case sensitive
-                    </label>
-                </div>
-            </div>
-
-            <div class="mb-3">
-                <label for="begin" class="form-label">After</label>
-                <input type="text" class="form-control" id="begin" name="begin" value="{{ begin }}">
-                <label for="end" class="form-label">Until</label>
-                <input type="text" class="form-control" id="end" name="end" value="{{ end }}">
-            </div>
-
-            <div class="mb-3">
-                <label for="" class="form-label">Kind</label>
-                {% for kind in kinds_avail %}
-                <div class="form-check">
-                    <input class="form-check-input" type="checkbox" name="kind" value="{{ kind }}" id="kind_{{ kind }}"
-                        {% if kind in kinds %} checked {% endif %}>
-                    <label class="form-check-label" for="kind_{{ kind }}">
-                        {{ kind }}
-                    </label>
-                </div>
-                {% endfor %}
-            </div>
-
-            <div class="mb-3">
-                <label for="" class="form-label">Equipment</label>
-                {% for equipment in equipments_avail %}
-                <div class="form-check">
-                    <input class="form-check-input" type="checkbox" name="equipment" value="{{ equipment }}"
-                        id="equipment_{{ equipment }}" {% if equipment in equipments %} checked {% endif %}>
-                    <label class="form-check-label" for="equipment_{{ equipment }}">
-                        {{ equipment }}
-                    </label>
-                </div>
-                {% endfor %}
-            </div>
-
-            <button type="submit" class="btn btn-primary">Search</button>
-        </form>
-    </div>
-
-    <div class="col-md-10">
-        <table class="table table-sort table-arrows">
-            <thead>
-                <tr>
-                    <th>Name</th>
-                    <th>Start</th>
-                    <th>Kind</th>
-                    <th class="numeric-sort">Distance</th>
-                    <th>Elapsed time</th>
-                </tr>
-            </thead>
-            <tbody>
-                {% for index, activity in activities %}
-                <tr>
-                    <td><a href="{{ url_for('activity.show', id=activity['id']) }}">{{ activity['name'] }}</a></td>
-                    <td>{{ activity['start']|dt }}</td>
-                    <td>{{ activity['kind'] }}</td>
-                    <td>{{ '%.1f' % activity["distance_km"] }} km</td>
-                    <td>{{ activity.elapsed_time|td }}</td>
-                </tr>
-                {% endfor %}
-            </tbody>
-        </table>
-    </div>
+<div class="mb-3">
+    {{ search_form(query, equipments_avail, kinds_avail) }}
 </div>
+
+<table class="table table-sort table-arrows">
+    <thead>
+        <tr>
+            <th>Name</th>
+            <th>Start</th>
+            <th>Kind</th>
+            <th class="numeric-sort">Distance</th>
+            <th>Elapsed time</th>
+        </tr>
+    </thead>
+    <tbody>
+        {% for index, activity in activities %}
+        <tr>
+            <td><a href="{{ url_for('activity.show', id=activity['id']) }}">{{ activity['name'] }}</a></td>
+            <td>
+                {% if activity['start'] is defined %}
+                {{ activity['start']|dt }}
+                {% endif %}
+            </td>
+            <td>{{ activity['kind'] }}</td>
+            <td>{{ '%.1f' % activity["distance_km"] }} km</td>
+            <td>{{ activity.elapsed_time|td }}</td>
+        </tr>
+        {% endfor %}
+    </tbody>
+</table>
 {% endblock %}