geo-activity-playground 0.28.0__tar.gz → 0.29.1__tar.gz

{geo_activity_playground-0.28.0 → geo_activity_playground-0.29.1}/PKG-INFO

@@ -1,14 +1,13 @@
 Metadata-Version: 2.1
 Name: geo-activity-playground
-Version: 0.28.0
+Version: 0.29.1
 Summary: Analysis of geo data activities like rides, runs or hikes.
 License: MIT
 Author: Martin Ueding
 Author-email: mu@martin-ueding.de
-Requires-Python: >=3.9,<3.13
+Requires-Python: >=3.10,<3.13
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
@@ -30,7 +29,7 @@ Requires-Dist: python-dateutil (>=2.8.2,<3.0.0)
 Requires-Dist: requests (>=2.28.1,<3.0.0)
 Requires-Dist: scipy (>=1.8.1,<2.0.0)
 Requires-Dist: shapely (>=2.0.5,<3.0.0)
-Requires-Dist: stravalib (>=1.3.3,<2.0.0)
+Requires-Dist: stravalib (>=2.0,<3.0)
 Requires-Dist: tcxreader (>=0.4.5,<0.5.0)
 Requires-Dist: tomli (>=2.0.1,<3.0.0) ; python_version < "3.11"
 Requires-Dist: tqdm (>=4.64.0,<5.0.0)

{geo_activity_playground-0.28.0 → geo_activity_playground-0.29.1}/geo_activity_playground/core/activities.py

@@ -2,6 +2,7 @@ import datetime
 import functools
 import logging
 import pickle
+from typing import Any
 from typing import Iterator
 from typing import Optional
 from typing import TypedDict
@@ -103,7 +104,7 @@ def build_activity_meta() -> None:
 
 class ActivityRepository:
     def __init__(self) -> None:
-        self.meta = None
+        self.meta = pd.DataFrame()
 
     def __len__(self) -> int:
         return len(self.meta)
@@ -116,10 +117,6 @@ class ActivityRepository:
             if activity_id in self.meta["id"]:
                 return True
 
-        for activity_meta in self._loose_activities:
-            if activity_meta["id"] == activity_id:
-                return True
-
         return False
 
     def last_activity_date(self) -> Optional[datetime.datetime]:
@@ -198,7 +195,7 @@ def make_geojson_color_line(time_series: pd.DataFrame) -> str:
     return geojson.dumps(feature_collection)
 
 
-def make_speed_color_bar(time_series: pd.DataFrame) -> dict[str, str]:
+def make_speed_color_bar(time_series: pd.DataFrame) -> dict[str, Any]:
     speed_without_na = time_series["speed"].dropna()
     low = min(speed_without_na)
     high = max(speed_without_na)

{geo_activity_playground-0.28.0 → geo_activity_playground-0.29.1}/geo_activity_playground/core/config.py

@@ -21,6 +21,8 @@ logger = logging.getLogger(__name__)
 @dataclasses.dataclass
 class Config:
     birth_year: Optional[int] = None
+    color_scheme_for_counts: str = "viridis"
+    color_scheme_for_kind: str = "category10"
     equipment_offsets: dict[str, float] = dataclasses.field(default_factory=dict)
     explorer_zoom_levels: list[int] = dataclasses.field(
         default_factory=lambda: [14, 17]
@@ -52,6 +54,7 @@ class ConfigAccessor:
         return self._config
 
     def save(self) -> None:
+        print(self._config)
         with open(new_config_file(), "w") as f:
             json.dump(
                 dataclasses.asdict(self._config),

{geo_activity_playground-0.28.0 → geo_activity_playground-0.29.1}/geo_activity_playground/core/paths.py

@@ -1,6 +1,7 @@
 """
 Paths within the playground and cache.
 """
+import contextlib
 import functools
 import pathlib
 import typing
@@ -24,6 +25,15 @@ def file_wrapper(path: pathlib.Path) -> typing.Callable[[], pathlib.Path]:
     return wrapper
 
 
+@contextlib.contextmanager
+def atomic_open(path: pathlib.Path, mode: str):
+    temp_path = path.with_stem(path.stem + "-temp")
+    with open(temp_path, mode) as f:
+        yield f
+    path.unlink(missing_ok=True)
+    temp_path.rename(path)
+
+
 _cache_dir = pathlib.Path("Cache")
 
 _activity_dir = _cache_dir / "Activity"

{geo_activity_playground-0.28.0 → geo_activity_playground-0.29.1}/geo_activity_playground/core/tasks.py

@@ -8,6 +8,7 @@ from typing import Generic
 from typing import Sequence
 from typing import TypeVar
 
+from geo_activity_playground.core.paths import atomic_open
 from geo_activity_playground.core.paths import cache_dir
 
 
@@ -24,11 +25,8 @@ def stored_object(path: pathlib.Path, default):
 
     yield payload
 
-    temp_location = path.with_suffix(".tmp")
-    with open(temp_location, "wb") as f:
+    with atomic_open(path, "wb") as f:
         pickle.dump(payload, f)
-    path.unlink(missing_ok=True)
-    temp_location.rename(path)
 
 
 def work_tracker_path(name: str) -> pathlib.Path:
@@ -68,6 +66,9 @@ class WorkTracker:
     def discard(self, id) -> None:
         self._done.discard(id)
 
+    def reset(self) -> None:
+        self._done = set()
+
     def close(self) -> None:
         with open(self._path, "wb") as f:
             pickle.dump(self._done, f)

{geo_activity_playground-0.28.0 → geo_activity_playground-0.29.1}/geo_activity_playground/core/time_conversion.py

@@ -2,7 +2,7 @@ import numpy as np
 import pandas as pd
 
 
-def convert_to_datetime_ns(date) -> np.datetime64:
+def convert_to_datetime_ns(date) -> np.datetime64 | pd.Series:
     if isinstance(date, pd.Series):
         ts = pd.to_datetime(date)
         ts = ts.dt.tz_localize(None)

{geo_activity_playground-0.28.0 → geo_activity_playground-0.29.1}/geo_activity_playground/explorer/tile_visits.py

@@ -14,6 +14,7 @@ from tqdm import tqdm
 
 from geo_activity_playground.core.activities import ActivityRepository
 from geo_activity_playground.core.config import Config
+from geo_activity_playground.core.paths import atomic_open
 from geo_activity_playground.core.paths import tiles_per_time_series
 from geo_activity_playground.core.tasks import try_load_pickle
 from geo_activity_playground.core.tasks import work_tracker_path
@@ -58,7 +59,7 @@ class TileEvolutionState:
 class TileState(TypedDict):
     tile_visits: dict[int, dict[tuple[int, int], TileInfo]]
     tile_history: dict[int, pd.DataFrame]
-    activities_per_tile: dict[int, set[int]]
+    activities_per_tile: dict[int, dict[tuple[int, int], set[int]]]
     processed_activities: set[int]
     evolution_state: dict[int, TileEvolutionState]
     version: int
@@ -79,11 +80,12 @@ class TileVisitAccessor:
             self.tile_state = make_tile_state()
             # TODO: Reset work tracker
 
+    def reset(self) -> None:
+        self.tile_state = make_tile_state()
+
     def save(self) -> None:
-        tmp_path = self.PATH.with_suffix(".tmp")
-        with open(tmp_path, "wb") as f:
+        with atomic_open(self.PATH, "wb") as f:
             pickle.dump(self.tile_state, f)
-        tmp_path.rename(self.PATH)
 
 
 def make_defaultdict_dict():
@@ -106,20 +108,52 @@ def make_tile_state() -> TileState:
     return tile_state
 
 
+def _consistency_check(
+    repository: ActivityRepository, tile_visit_accessor: TileVisitAccessor
+) -> bool:
+    present_activity_ids = set(repository.get_activity_ids())
+
+    for zoom, activities_per_tile in tile_visit_accessor.tile_state[
+        "activities_per_tile"
+    ].items():
+        for tile, tile_activity_ids in activities_per_tile.items():
+            deleted_activity_ids = tile_activity_ids - present_activity_ids
+            if deleted_activity_ids:
+                logger.info(f"Activities {deleted_activity_ids} have been deleted.")
+                return False
+
+    for zoom, tile_visits in tile_visit_accessor.tile_state["tile_visits"].items():
+        for tile, meta in tile_visits.items():
+            if meta["first_id"] not in present_activity_ids:
+                logger.info(f"Activity {meta['first_id']} have been deleted.")
+                return False
+            if meta["last_id"] not in present_activity_ids:
+                logger.info(f"Activity {meta['last_id']} have been deleted.")
+                return False
+
+    return True
+
+
 def compute_tile_visits_new(
     repository: ActivityRepository, tile_visit_accessor: TileVisitAccessor
 ) -> None:
     work_tracker = WorkTracker(work_tracker_path("tile-state"))
+
+    if not _consistency_check(repository, tile_visit_accessor):
+        logger.warning("Need to recompute Explorer Tiles due to deleted activities.")
+        tile_visit_accessor.reset()
+        work_tracker.reset()
+
     for activity_id in tqdm(
-        work_tracker.filter(repository.get_activity_ids()), desc="Tile visits (new)"
+        work_tracker.filter(repository.get_activity_ids()), desc="Tile visits"
     ):
-        do_tile_stuff(repository, tile_visit_accessor.tile_state, activity_id)
+        _process_activity(repository, tile_visit_accessor.tile_state, activity_id)
         work_tracker.mark_done(activity_id)
     tile_visit_accessor.save()
     work_tracker.close()
 
 
-def do_tile_stuff(
+def _process_activity(
     repository: ActivityRepository, tile_state: TileState, activity_id: int
 ) -> None:
     activity = repository.get_activity_by_id(activity_id)
@@ -131,7 +165,7 @@ def do_tile_stuff(
     for zoom in reversed(range(20)):
         activities_per_tile = tile_state["activities_per_tile"][zoom]
 
-        new_tile_history_soa = {
+        new_tile_history_soa: dict[str, list] = {
             "activity_id": [],
             "time": [],
             "tile_x": [],
@@ -145,7 +179,7 @@ def do_tile_stuff(
             zip(activity_tiles["tile_x"], activity_tiles["tile_y"]),
         ):
             if activity["consider_for_achievements"]:
-                if tile not in activities_per_tile:
+                if tile not in tile_state["tile_visits"][zoom]:
                     new_tile_history_soa["activity_id"].append(activity_id)
                     new_tile_history_soa["time"].append(time)
                     new_tile_history_soa["tile_x"].append(tile[0])

{geo_activity_playground-0.28.0 → geo_activity_playground-0.29.1}/geo_activity_playground/importers/activity_parsers.py

@@ -3,10 +3,10 @@ import gzip
 import logging
 import pathlib
 import xml
+from collections.abc import Iterator
 
 import charset_normalizer
 import dateutil.parser
-import fitdecode
 import fitdecode.exceptions
 import gpxpy
 import pandas as pd
@@ -246,26 +246,37 @@ def read_kml_activity(path: pathlib.Path, opener) -> pd.DataFrame:
     with opener(path, "rb") as f:
         kml_dict = xmltodict.parse(f)
     doc = kml_dict["kml"]["Document"]
-    keypoint_folder = doc["Folder"]
-    placemark = keypoint_folder["Placemark"]
-    track = placemark["gx:Track"]
     rows = []
-    for when, where in zip(track["when"], track["gx:coord"]):
-        time = dateutil.parser.parse(when)
-        time = convert_to_datetime_ns(time)
-        parts = where.split(" ")
-        if len(parts) == 2:
-            lon, lat = parts
-            alt = None
-        if len(parts) == 3:
-            lon, lat, alt = parts
-        row = {"time": time, "latitude": float(lat), "longitude": float(lon)}
-        if alt is not None:
-            row["altitude"] = float(alt)
-        rows.append(row)
+    for keypoint_folder in _list_or_scalar(doc["Folder"]):
+        for placemark in _list_or_scalar(keypoint_folder["Placemark"]):
+            for track in _list_or_scalar(placemark.get("gx:Track", [])):
+                for when, where in zip(track["when"], track["gx:coord"]):
+                    time = dateutil.parser.parse(when)
+                    time = convert_to_datetime_ns(time)
+                    parts = where.split(" ")
+                    if len(parts) == 2:
+                        lon, lat = parts
+                        alt = None
+                    if len(parts) == 3:
+                        lon, lat, alt = parts
+                    row = {
+                        "time": time,
+                        "latitude": float(lat),
+                        "longitude": float(lon),
+                    }
+                    if alt is not None:
+                        row["altitude"] = float(alt)
+                    rows.append(row)
     return pd.DataFrame(rows)
 
 
+def _list_or_scalar(thing) -> Iterator:
+    if isinstance(thing, list):
+        yield from thing
+    else:
+        yield thing
+
+
 def read_simra_activity(path: pathlib.Path, opener) -> pd.DataFrame:
     data = pd.read_csv(path, header=1)
     data["time"] = data["timeStamp"].apply(

{geo_activity_playground-0.28.0 → geo_activity_playground-0.29.1}/geo_activity_playground/importers/csv_parser.py

@@ -20,9 +20,8 @@ This module implements a "recursive descent parser" that parses this grammar.
 
 def parse_csv(text: str) -> list[list]:
     text = text.strip() + "\n"
-    result = {}
     index = 0
-    result = []
+    result: list[list] = []
     while index < len(text):
         line, index = _parse_line(text, index)
         result.append(line)

{geo_activity_playground-0.28.0 → geo_activity_playground-0.29.1}/geo_activity_playground/importers/directory.py

@@ -126,11 +126,12 @@ def _cache_single_file(path: pathlib.Path) -> Optional[tuple[pathlib.Path, str]]
             raise
 
         if len(timeseries) == 0:
-            return
+            return None
 
         timeseries.to_parquet(timeseries_path)
         with open(file_metadata_path, "wb") as f:
             pickle.dump(activity_meta_from_file, f)
+    return None
 
 
 def get_file_hash(path: pathlib.Path) -> int:

{geo_activity_playground-0.28.0 → geo_activity_playground-0.29.1}/geo_activity_playground/webui/activity/controller.py

@@ -12,6 +12,8 @@ import pandas as pd
 from PIL import Image
 from PIL import ImageDraw
 
+from ...explorer.grid_file import make_grid_file_geojson
+from ...explorer.grid_file import make_grid_points
 from geo_activity_playground.core.activities import ActivityMeta
 from geo_activity_playground.core.activities import ActivityRepository
 from geo_activity_playground.core.activities import make_geojson_color_line
@@ -66,9 +68,27 @@ class ActivityController:
                 ]
                 == activity["id"]
             )
-            for zoom in [14, 17]
+            for zoom in sorted(self._config.explorer_zoom_levels)
         }
 
+        new_tiles_geojson = {}
+        for zoom in sorted(self._config.explorer_zoom_levels):
+            new_tiles = self._tile_visit_accessor.tile_state["tile_history"][zoom].loc[
+                self._tile_visit_accessor.tile_state["tile_history"][zoom][
+                    "activity_id"
+                ]
+                == activity["id"]
+            ]
+            if len(new_tiles):
+                points = make_grid_points(
+                    (
+                        (row["tile_x"], row["tile_y"])
+                        for index, row in new_tiles.iterrows()
+                    ),
+                    zoom,
+                )
+                new_tiles_geojson[zoom] = make_grid_file_geojson(points)
+
         result = {
             "activity": activity,
             "line_json": line_json,
@@ -81,6 +101,7 @@ class ActivityController:
             "date": activity["start"].date(),
             "time": activity["start"].time(),
             "new_tiles": new_tiles,
+            "new_tiles_geojson": new_tiles_geojson,
         }
         if (
             heart_zones := _extract_heart_rate_zones(

{geo_activity_playground-0.28.0 → geo_activity_playground-0.29.1}/geo_activity_playground/webui/activity/templates/activity/show.html.j2

@@ -136,6 +136,39 @@
 <p>Not happy with the displayed data? <a href="{{ url_for('settings.sharepic') }}">Change share picture
         settings</a>.</p>
 
+{% if new_tiles_geojson %}
+<h2>New explorer tiles</h2>
+<p>With this activity you have explored new explorer tiles. The following maps show the new tiles on the respective zoom
+    levels.</p>
+<script>
+    function add_map(id, geojson) {
+        let map = L.map(`map-${id}`, {
+            fullscreenControl: true
+        })
+        L.tileLayer('/tile/color/{z}/{x}/{y}.png', {
+            maxZoom: 19,
+            attribution: '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a>'
+        }).addTo(map)
+
+        let geojson_layer = L.geoJSON(geojson).addTo(map)
+        map.fitBounds(geojson_layer.getBounds())
+        return map
+    }
+</script>
+
+<div class="row mb-3">
+    {% for zoom, geojson in new_tiles_geojson.items() %}
+    <div class="col-md-6">
+        <h3>Zoom {{ zoom }}</h3>
+        <div id="map-{{ zoom }}" style="height: 300px; width: 100%;"></div>
+        <script>
+            let map{{ zoom }} = add_map("{{ zoom }}", {{ geojson | safe }})
+        </script>
+    </div>
+    {% endfor %}
+</div>
+{% endif %}
+
 {% if similar_activites|length > 0 %}
 <div class="row mb-3">
     <div class="col">

{geo_activity_playground-0.28.0 → geo_activity_playground-0.29.1}/geo_activity_playground/webui/app.py

@@ -5,7 +5,6 @@ import secrets
 
 from flask import Flask
 from flask import render_template
-from flask import request
 
 from ..core.activities import ActivityRepository
 from ..explorer.tile_visits import TileVisitAccessor
@@ -16,31 +15,20 @@ from .entry_controller import EntryController
 from .equipment.blueprint import make_equipment_blueprint
 from .explorer.blueprint import make_explorer_blueprint
 from .heatmap.blueprint import make_heatmap_blueprint
-from .search_controller import SearchController
+from .search.blueprint import make_search_blueprint
 from .square_planner.blueprint import make_square_planner_blueprint
 from .summary.blueprint import make_summary_blueprint
 from .tile.blueprint import make_tile_blueprint
 from .upload.blueprint import make_upload_blueprint
+from geo_activity_playground.core.config import Config
 from geo_activity_playground.core.config import ConfigAccessor
 from geo_activity_playground.webui.auth.blueprint import make_auth_blueprint
 from geo_activity_playground.webui.authenticator import Authenticator
 from geo_activity_playground.webui.settings.blueprint import make_settings_blueprint
 
 
-def route_search(app: Flask, repository: ActivityRepository) -> None:
-    search_controller = SearchController(repository)
-
-    @app.route("/search", methods=["POST"])
-    def search():
-        form_input = request.form
-        return render_template(
-            "search.html.j2",
-            **search_controller.render_search_results(form_input["name"])
-        )
-
-
-def route_start(app: Flask, repository: ActivityRepository) -> None:
-    entry_controller = EntryController(repository)
+def route_start(app: Flask, repository: ActivityRepository, config: Config) -> None:
+    entry_controller = EntryController(repository, config)
 
     @app.route("/")
     def index():
@@ -66,7 +54,6 @@ def web_ui_main(
     host: str,
     port: int,
 ) -> None:
-
     repository.reload()
 
     app = Flask(__name__)
@@ -75,8 +62,7 @@ def web_ui_main(
 
     authenticator = Authenticator(config_accessor())
 
-    route_search(app, repository)
-    route_start(app, repository)
+    route_start(app, repository, config_accessor())
 
     app.register_blueprint(make_auth_blueprint(authenticator), url_prefix="/auth")
 
@@ -111,7 +97,11 @@ def web_ui_main(
         url_prefix="/square-planner",
     )
     app.register_blueprint(
-        make_summary_blueprint(repository),
+        make_search_blueprint(repository),
+        url_prefix="/search",
+    )
+    app.register_blueprint(
+        make_summary_blueprint(repository, config_accessor()),
         url_prefix="/summary",
     )
     app.register_blueprint(make_tile_blueprint(), url_prefix="/tile")

{geo_activity_playground-0.28.0 → geo_activity_playground-0.29.1}/geo_activity_playground/webui/authenticator.py

@@ -14,9 +14,6 @@ class Authenticator:
         self._config = config
 
     def is_authenticated(self) -> bool:
-        print(
-            f"Password={self._config.upload_password}, Session={session.get('is_authenticated', False)}"
-        )
         return not self._config.upload_password or session.get(
             "is_authenticated", False
         )

{geo_activity_playground-0.28.0 → geo_activity_playground-0.29.1}/geo_activity_playground/webui/entry_controller.py

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

{geo_activity_playground-0.28.0 → geo_activity_playground-0.29.1}/geo_activity_playground/webui/explorer/controller.py

@@ -95,7 +95,7 @@ class ExplorerController:
         x2, y2 = compute_tile(south, east, zoom)
         tile_bounds = Bounds(x1, y1, x2 + 2, y2 + 2)
 
-        tile_histories = self._tile_visit_accessor.histories
+        tile_histories = self._tile_visit_accessor.tile_state["tile_history"]
         tiles = tile_histories[zoom]
         points = get_border_tiles(tiles, zoom, tile_bounds)
         if suffix == "geojson":
@@ -108,7 +108,7 @@ class ExplorerController:
         x2, y2 = compute_tile(south, east, zoom)
         tile_bounds = Bounds(x1, y1, x2 + 2, y2 + 2)
 
-        tile_visits = self._tile_visit_accessor.visits
+        tile_visits = self._tile_visit_accessor.tile_state["tile_visits"]
         tiles = tile_visits[zoom]
         points = make_grid_points(
             (tile for tile in tiles.keys() if tile_bounds.contains(*tile)), zoom
@@ -161,6 +161,7 @@ def get_three_color_tiles(
             "last_visit": tile_data["last_time"].date().isoformat(),
             "num_visits": len(tile_data["activity_ids"]),
             "square": False,
+            "tile": f"({zoom}, {tile[0]}, {tile[1]})",
         }
 
     # Mark biggest square.

{geo_activity_playground-0.28.0 → geo_activity_playground-0.29.1}/geo_activity_playground/webui/explorer/templates/explorer/index.html.j2

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

{geo_activity_playground-0.28.0 → geo_activity_playground-0.29.1}/geo_activity_playground/webui/heatmap/heatmap_controller.py

@@ -123,6 +123,7 @@ class HeatmapController:
                         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)
         return tile_counts
 

geo_activity_playground-0.29.1/geo_activity_playground/webui/plot_util.py

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

geo_activity_playground-0.29.1/geo_activity_playground/webui/search/blueprint.py

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