geo-activity-playground 0.21.2__tar.gz → 0.23.0__tar.gz

{geo_activity_playground-0.21.2 → geo_activity_playground-0.23.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: geo-activity-playground
-Version: 0.21.2
+Version: 0.23.0
 Summary: Analysis of geo data activities like rides, runs or hikes.
 License: MIT
 Author: Martin Ueding

{geo_activity_playground-0.21.2 → geo_activity_playground-0.23.0}/geo_activity_playground/__main__.py

@@ -7,17 +7,13 @@ import sys
 import coloredlogs
 
 from .importers.strava_checkout import convert_strava_checkout
-from .importers.strava_checkout import import_from_strava_checkout
 from geo_activity_playground.core.activities import ActivityRepository
-from geo_activity_playground.core.activities import embellish_time_series
 from geo_activity_playground.core.cache_migrations import apply_cache_migrations
 from geo_activity_playground.core.config import get_config
-from geo_activity_playground.explorer.tile_visits import compute_tile_evolution
-from geo_activity_playground.explorer.tile_visits import compute_tile_visits
+from geo_activity_playground.explorer.tile_visits import TileVisitAccessor
 from geo_activity_playground.explorer.video import explorer_video_main
-from geo_activity_playground.importers.directory import import_from_directory
-from geo_activity_playground.importers.strava_api import import_from_strava_api
 from geo_activity_playground.webui.app import webui_main
+from geo_activity_playground.webui.upload_controller import scan_for_activities
 
 logger = logging.getLogger(__name__)
 
@@ -68,7 +64,7 @@ def main() -> None:
     subparser = subparsers.add_parser("serve", help="Launch webserver")
     subparser.set_defaults(
         func=lambda options: webui_main(
-            make_activity_repository(options.basedir, options.skip_strava),
+            *make_activity_repository(options.basedir, options.skip_strava),
             host=options.host,
             port=options.port,
         )
@@ -99,7 +95,7 @@ def main() -> None:
 
 def make_activity_repository(
     basedir: pathlib.Path, skip_strava: bool
-) -> ActivityRepository:
+) -> tuple[ActivityRepository, TileVisitAccessor, dict]:
     os.chdir(basedir)
     apply_cache_migrations()
     config = get_config()
@@ -111,27 +107,11 @@ def make_activity_repository(
         sys.exit(1)
 
     repository = ActivityRepository()
+    tile_visit_accessor = TileVisitAccessor()
 
-    if pathlib.Path("Activities").exists():
-        import_from_directory(
-            repository,
-            config.get("metadata_extraction_regexes", []),
-        )
-    if pathlib.Path("Strava Export").exists():
-        import_from_strava_checkout(repository)
-    if "strava" in config and not skip_strava:
-        import_from_strava_api(repository)
-
-    if len(repository) == 0:
-        logger.error(
-            f"No activities found. You need to either add activity files (GPX, FIT, …) to {basedir/'Activities'} or set up the Strava API. Starting without any activities is unfortunately not supported."
-        )
-        sys.exit(1)
+    scan_for_activities(repository, tile_visit_accessor, config, skip_strava)
 
-    embellish_time_series(repository)
-    compute_tile_visits(repository)
-    compute_tile_evolution()
-    return repository
+    return repository, tile_visit_accessor, config
 
 
 if __name__ == "__main__":

{geo_activity_playground-0.21.2 → geo_activity_playground-0.23.0}/geo_activity_playground/core/activities.py

@@ -78,6 +78,11 @@ class ActivityRepository:
                 f"Adding {len(self._loose_activities)} activities to the repository …"
             )
             new_df = pd.DataFrame(self._loose_activities)
+            if not pd.api.types.is_dtype_equal(
+                new_df["start"].dtype, "datetime64[ns, UTC]"
+            ):
+                new_df["start"] = new_df["start"].dt.tz_localize("UTC")
+                new_df["start"] = new_df["start"].dt.tz_convert("UTC")
             if len(self.meta):
                 new_ids_set = set(new_df["id"])
                 is_kept = [
@@ -89,7 +94,7 @@ class ActivityRepository:
             self.meta = pd.concat([old_df, new_df])
             assert pd.api.types.is_dtype_equal(
                 self.meta["start"].dtype, "datetime64[ns, UTC]"
-            ), self.meta["start"].dtype
+            ), (self.meta["start"].dtype, self.meta["start"].iloc[0])
             self.save()
             self._loose_activities = []
 
@@ -120,10 +125,11 @@ class ActivityRepository:
     def activity_ids(self) -> set[int]:
         return set(self.meta.index)
 
-    def iter_activities(self, new_to_old=True) -> Iterator[ActivityMeta]:
+    def iter_activities(self, new_to_old=True, dropna=False) -> Iterator[ActivityMeta]:
         direction = -1 if new_to_old else 1
         for index, row in self.meta[::direction].iterrows():
-            yield row
+            if not dropna or not pd.isna(row["start"]):
+                yield row
 
     @functools.lru_cache()
     def get_activity_by_id(self, id: int) -> ActivityMeta:

{geo_activity_playground-0.21.2 → geo_activity_playground-0.23.0}/geo_activity_playground/core/activity_parsers.py

@@ -12,6 +12,7 @@ import numpy as np
 import pandas as pd
 import tcxreader.tcxreader
 import xmltodict
+from pandas._libs import NaTType
 
 from geo_activity_playground.core.activities import ActivityMeta
 from geo_activity_playground.core.activities import embellish_single_time_series
@@ -126,8 +127,12 @@ def read_fit_activity(path: pathlib.Path, open) -> tuple[ActivityMeta, pd.DataFr
                         and values.get("position_long", None)
                     ):
                         time = values["timestamp"]
-                        assert isinstance(time, datetime.datetime)
-                        time = time.astimezone(datetime.timezone.utc)
+                        if isinstance(time, datetime.datetime):
+                            time = time.astimezone(datetime.timezone.utc)
+                        elif time is None or isinstance(time, int):
+                            time = pd.NaT
+                        else:
+                            raise RuntimeError(f"Cannot parse time: {time} in {path}.")
                         row = {
                             "time": time,
                             "latitude": values["position_lat"] / ((2**32) / 360),
@@ -202,10 +207,13 @@ def read_gpx_activity(path: pathlib.Path, open) -> pd.DataFrame:
             for point in segment.points:
                 if isinstance(point.time, datetime.datetime):
                     time = point.time
-                else:
+                    time = time.astimezone(datetime.timezone.utc)
+                elif isinstance(point.time, str):
                     time = dateutil.parser.parse(str(point.time))
-                assert isinstance(time, datetime.datetime)
-                time = time.astimezone(datetime.timezone.utc)
+                    time = time.astimezone(datetime.timezone.utc)
+                else:
+                    time = pd.NaT
+                    time.tz_localize("UTC")
                 points.append((time, point.latitude, point.longitude, point.elevation))
 
     df = pd.DataFrame(points, columns=["time", "latitude", "longitude", "altitude"])
@@ -233,6 +241,7 @@ def read_tcx_activity(path: pathlib.Path, opener) -> pd.DataFrame:
         content = f.read().strip()
 
     stripped_file = pathlib.Path("Cache/temp.tcx")
+    stripped_file.parent.mkdir(exist_ok=True)
     with open(stripped_file, "wb") as f:
         f.write(content)
     data = tcx_reader.read(str(stripped_file))

{geo_activity_playground-0.21.2 → geo_activity_playground-0.23.0}/geo_activity_playground/core/heatmap.py

@@ -22,7 +22,7 @@ class GeoBounds:
     lon_max: float
 
 
-def get_bounds(lat_lon_data: np.array) -> GeoBounds:
+def get_bounds(lat_lon_data: np.ndarray) -> GeoBounds:
     return GeoBounds(*np.min(lat_lon_data, axis=0), *np.max(lat_lon_data, axis=0))
 
 
@@ -106,7 +106,7 @@ def get_sensible_zoom_level(
     )
 
 
-def build_map_from_tiles(tile_bounds: TileBounds) -> np.array:
+def build_map_from_tiles(tile_bounds: TileBounds) -> np.ndarray:
     background = np.zeros((*tile_bounds.shape, 3))
 
     for x in range(tile_bounds.x_tile_min, tile_bounds.x_tile_max):

{geo_activity_playground-0.21.2 → geo_activity_playground-0.23.0}/geo_activity_playground/explorer/grid_file.py

@@ -16,7 +16,7 @@ logger = logging.getLogger(__name__)
 
 def get_border_tiles(
     tiles: pd.DataFrame, zoom: int, tile_bounds: Bounds
-) -> list[list[list[float]]]:
+) -> list[list[tuple[float, float]]]:
     logger.info("Generate border tiles …")
     tile_set = set(zip(tiles["tile_x"], tiles["tile_y"]))
     border_tiles = set()
@@ -28,7 +28,9 @@ def get_border_tiles(
     return make_grid_points(border_tiles, zoom)
 
 
-def get_explored_tiles(tiles: pd.DataFrame, zoom: int) -> list[list[list[float]]]:
+def get_explored_tiles(
+    tiles: pd.DataFrame, zoom: int
+) -> list[list[tuple[float, float]]]:
     return make_grid_points(zip(tiles["tile_x"], tiles["tile_y"]), zoom)
 
 
@@ -66,7 +68,7 @@ def make_explorer_rectangle(
 
 def make_grid_points(
     tiles: Iterable[tuple[int, int]], zoom: int
-) -> list[list[list[float]]]:
+) -> list[list[tuple[float, float]]]:
     result = []
     for tile_x, tile_y in tiles:
         tile = [
@@ -80,7 +82,7 @@ def make_grid_points(
     return result
 
 
-def make_grid_file_gpx(grid_points: list[list[list[float]]]) -> str:
+def make_grid_file_gpx(grid_points: list[list[tuple[float, float]]]) -> str:
     gpx = gpxpy.gpx.GPX()
     gpx_track = gpxpy.gpx.GPXTrack()
     gpx.tracks.append(gpx_track)
@@ -93,7 +95,7 @@ def make_grid_file_gpx(grid_points: list[list[list[float]]]) -> str:
     return gpx.to_xml()
 
 
-def make_grid_file_geojson(grid_points: list[list[list[float]]]) -> str:
+def make_grid_file_geojson(grid_points: list[list[tuple[float, float]]]) -> str:
     fc = geojson.FeatureCollection(
         [
             geojson.Feature(

{geo_activity_playground-0.21.2 → geo_activity_playground-0.23.0}/geo_activity_playground/explorer/tile_visits.py

@@ -20,18 +20,39 @@ from geo_activity_playground.core.tiles import interpolate_missing_tile
 
 logger = logging.getLogger(__name__)
 
-TILE_EVOLUTION_STATES_PATH = pathlib.Path("Cache/tile-evolution-state.pickle")
-TILE_HISTORIES_PATH = pathlib.Path(f"Cache/tile-history.pickle")
-TILE_VISITS_PATH = pathlib.Path(f"Cache/tile-visits.pickle")
 
+class TileVisitAccessor:
+    TILE_EVOLUTION_STATES_PATH = pathlib.Path("Cache/tile-evolution-state.pickle")
+    TILE_HISTORIES_PATH = pathlib.Path(f"Cache/tile-history.pickle")
+    TILE_VISITS_PATH = pathlib.Path(f"Cache/tile-visits.pickle")
 
-def compute_tile_visits(repository: ActivityRepository) -> None:
-    tile_visits: dict[int, dict[tuple[int, int], dict[str, Any]]] = try_load_pickle(
-        TILE_VISITS_PATH
-    ) or collections.defaultdict(dict)
-    tile_history: dict[int, pd.DataFrame] = try_load_pickle(
-        TILE_HISTORIES_PATH
-    ) or collections.defaultdict(pd.DataFrame)
+    def __init__(self) -> None:
+        self.visits: dict[int, dict[tuple[int, int], dict[str, Any]]] = try_load_pickle(
+            self.TILE_VISITS_PATH
+        ) or collections.defaultdict(dict)
+
+        self.histories: dict[int, pd.DataFrame] = try_load_pickle(
+            self.TILE_HISTORIES_PATH
+        ) or collections.defaultdict(pd.DataFrame)
+
+        self.states = try_load_pickle(
+            self.TILE_EVOLUTION_STATES_PATH
+        ) or collections.defaultdict(TileEvolutionState)
+
+    def save(self) -> None:
+        with open(self.TILE_VISITS_PATH, "wb") as f:
+            pickle.dump(self.visits, f)
+
+        with open(self.TILE_HISTORIES_PATH, "wb") as f:
+            pickle.dump(self.histories, f)
+
+        with open(self.TILE_EVOLUTION_STATES_PATH, "wb") as f:
+            pickle.dump(self.states, f)
+
+
+def compute_tile_visits(
+    repository: ActivityRepository, tile_visits_accessor: TileVisitAccessor
+) -> None:
 
     work_tracker = WorkTracker("tile-visits")
     activity_ids_to_process = work_tracker.filter(repository.activity_ids)
@@ -43,8 +64,8 @@ def compute_tile_visits(repository: ActivityRepository) -> None:
         for zoom in range(20):
             for time, tile_x, tile_y in _tiles_from_points(time_series, zoom):
                 tile = (tile_x, tile_y)
-                if tile in tile_visits[zoom]:
-                    d = tile_visits[zoom][tile]
+                if tile in tile_visits_accessor.visits[zoom]:
+                    d = tile_visits_accessor.visits[zoom][tile]
                     if d["first_time"] > time:
                         d["first_time"] = time
                         d["first_id"] = activity_id
@@ -53,7 +74,7 @@ def compute_tile_visits(repository: ActivityRepository) -> None:
                         d["last_id"] = activity_id
                     d["activity_ids"].add(activity_id)
                 else:
-                    tile_visits[zoom][tile] = {
+                    tile_visits_accessor.visits[zoom][tile] = {
                         "first_time": time,
                         "first_id": activity_id,
                         "last_time": time,
@@ -71,16 +92,19 @@ def compute_tile_visits(repository: ActivityRepository) -> None:
         work_tracker.mark_done(activity_id)
 
     if activity_ids_to_process:
-        with open(TILE_VISITS_PATH, "wb") as f:
-            pickle.dump(tile_visits, f)
-
         for zoom, new_rows in new_tile_history_rows.items():
             new_df = pd.DataFrame(new_rows)
+            if not pd.api.types.is_dtype_equal(
+                new_df["time"].dtype, "datetime64[ns, UTC]"
+            ):
+                new_df["time"] = new_df["time"].dt.tz_localize("UTC")
+                new_df["time"] = new_df["time"].dt.tz_convert("UTC")
             new_df.sort_values("time", inplace=True)
-            tile_history[zoom] = pd.concat([tile_history[zoom], new_df])
+            tile_visits_accessor.histories[zoom] = pd.concat(
+                [tile_visits_accessor.histories[zoom], new_df]
+            )
 
-        with open(TILE_HISTORIES_PATH, "wb") as f:
-            pickle.dump(tile_history, f)
+        tile_visits_accessor.save()
 
     work_tracker.close()
 
@@ -123,23 +147,19 @@ class TileEvolutionState:
         self.square_y: Optional[int] = None
 
 
-def compute_tile_evolution() -> None:
-    with open(TILE_HISTORIES_PATH, "rb") as f:
-        tile_histories = pickle.load(f)
-
-    states = try_load_pickle(TILE_EVOLUTION_STATES_PATH) or collections.defaultdict(
-        TileEvolutionState
-    )
-
+def compute_tile_evolution(tile_visits_accessor: TileVisitAccessor) -> None:
     zoom_levels = list(reversed(list(range(20))))
 
     for zoom in tqdm(zoom_levels, desc="Compute explorer cluster evolution"):
-        _compute_cluster_evolution(tile_histories[zoom], states[zoom])
+        _compute_cluster_evolution(
+            tile_visits_accessor.histories[zoom], tile_visits_accessor.states[zoom]
+        )
     for zoom in tqdm(zoom_levels, desc="Compute explorer square evolution"):
-        _compute_square_history(tile_histories[zoom], states[zoom])
+        _compute_square_history(
+            tile_visits_accessor.histories[zoom], tile_visits_accessor.states[zoom]
+        )
 
-    with open(TILE_EVOLUTION_STATES_PATH, "wb") as f:
-        pickle.dump(states, f)
+    tile_visits_accessor.save()
 
 
 def _compute_cluster_evolution(tiles: pd.DataFrame, s: TileEvolutionState) -> None:

{geo_activity_playground-0.21.2 → geo_activity_playground-0.23.0}/geo_activity_playground/explorer/video.py

@@ -3,6 +3,7 @@ import math
 import pathlib
 from typing import Generator
 from typing import List
+from typing import Optional
 from typing import Set
 from typing import Tuple
 
@@ -23,8 +24,8 @@ def build_image(
     brightness: float = 1.0,
     width: int = 1920,
     height: int = 1080,
-    frame_counter: int = None,
-) -> Image.Image:
+    frame_counter: int = 0,
+) -> Optional[Image.Image]:
     path = pathlib.Path(f"video/{frame_counter:06d}.png")
     if path.exists():
         return None

{geo_activity_playground-0.21.2 → geo_activity_playground-0.23.0}/geo_activity_playground/importers/directory.py

@@ -49,9 +49,9 @@ def import_from_directory(
         paths_with_errors = [error for error in paths_with_errors if error]
 
     for path in tqdm(new_activity_paths, desc="Collate activity metadata"):
-        activity_id = _get_file_hash(path)
+        activity_id = get_file_hash(path)
         file_metadata_path = file_metadata_dir / f"{activity_id}.pickle"
-        work_tracker.mark_done(activity_id)
+        work_tracker.mark_done(path)
 
         if not file_metadata_path.exists():
             continue
@@ -87,7 +87,7 @@ def _cache_single_file(path: pathlib.Path) -> Optional[tuple[pathlib.Path, str]]
     activity_stream_dir = pathlib.Path("Cache/Activity Timeseries")
     file_metadata_dir = pathlib.Path("Cache/Activity Metadata")
 
-    activity_id = _get_file_hash(path)
+    activity_id = get_file_hash(path)
     timeseries_path = activity_stream_dir / f"{activity_id}.parquet"
     file_metadata_path = file_metadata_dir / f"{activity_id}.pickle"
 
@@ -110,7 +110,7 @@ def _cache_single_file(path: pathlib.Path) -> Optional[tuple[pathlib.Path, str]]
             pickle.dump(activity_meta_from_file, f)
 
 
-def _get_file_hash(path: pathlib.Path) -> int:
+def get_file_hash(path: pathlib.Path) -> int:
     file_hash = hashlib.blake2s()
     with open(path, "rb") as f:
         while chunk := f.read(8192):

{geo_activity_playground-0.21.2 → geo_activity_playground-0.23.0}/geo_activity_playground/importers/strava_api.py

@@ -103,12 +103,12 @@ def import_from_strava_api(repository: ActivityRepository) -> None:
         time.sleep(seconds_to_wait)
 
 
-def try_import_strava(repository: ActivityRepository) -> None:
-    get_after = (
-        repository.last_activity_date().isoformat().replace("+00:00", "Z")
-        if repository.last_activity_date() is not None
-        else "2000-01-01T00:00:00Z"
-    )
+def try_import_strava(repository: ActivityRepository) -> bool:
+    last = repository.last_activity_date()
+    if last is None:
+        get_after = "2000-01-01T00:00:00Z"
+    else:
+        get_after = last.isoformat().replace("+00:00", "Z")
 
     gear_names = {None: "None"}
 

{geo_activity_playground-0.21.2 → geo_activity_playground-0.23.0}/geo_activity_playground/importers/strava_checkout.py

@@ -2,6 +2,7 @@ import datetime
 import logging
 import pathlib
 import shutil
+import sys
 import traceback
 from typing import Optional
 from typing import Union
@@ -133,6 +134,13 @@ def import_from_strava_checkout(repository: ActivityRepository) -> None:
         dayfirst = False
     if activities.columns[0] == "Aktivitäts-ID":
         activities = pd.read_csv(checkout_path / "activities.csv", decimal=",")
+        if len(activities.columns) != len(EXPECTED_COLUMNS):
+            logger.error(
+                f"You are trying to import a Strava checkout where the `activities.csv` contains German column headers. In order to import this, we need to map these to the English ones. Unfortunately Strava has changed the number of columns. Your file has {len(activities.columns)} but we expect {len(EXPECTED_COLUMNS)}. This means that the program needs to be updated to match the new Strava export format. Please go to https://github.com/martin-ueding/geo-activity-playground/issues and open a new issue and share the following output in the ticket:"
+            )
+            print(activities.columns)
+            print(activities.dtypes)
+            sys.exit(1)
         activities.columns = EXPECTED_COLUMNS
         dayfirst = True
 

{geo_activity_playground-0.21.2 → geo_activity_playground-0.23.0}/geo_activity_playground/webui/app.py

@@ -1,3 +1,6 @@
+import json
+import pathlib
+import secrets
 import urllib
 
 from flask import Flask
@@ -9,6 +12,7 @@ from flask import Response
 from .locations_controller import LocationsController
 from .search_controller import SearchController
 from geo_activity_playground.core.activities import ActivityRepository
+from geo_activity_playground.explorer.tile_visits import TileVisitAccessor
 from geo_activity_playground.webui.activity_controller import ActivityController
 from geo_activity_playground.webui.calendar_controller import CalendarController
 from geo_activity_playground.webui.config_controller import ConfigController
@@ -26,6 +30,7 @@ from geo_activity_playground.webui.summary_controller import SummaryController
 from geo_activity_playground.webui.tile_controller import (
     TileController,
 )
+from geo_activity_playground.webui.upload_controller import UploadController
 
 
 def route_activity(app: Flask, repository: ActivityRepository) -> None:
@@ -113,8 +118,10 @@ def route_equipment(app: Flask, repository: ActivityRepository) -> None:
         return render_template("equipment.html.j2", **equipment_controller.render())
 
 
-def route_explorer(app: Flask, repository: ActivityRepository) -> None:
-    explorer_controller = ExplorerController(repository)
+def route_explorer(
+    app: Flask, repository: ActivityRepository, tile_visit_accessor: TileVisitAccessor
+) -> None:
+    explorer_controller = ExplorerController(repository, tile_visit_accessor)
 
     @app.route("/explorer/<zoom>")
     def explorer(zoom: str):
@@ -159,8 +166,10 @@ def route_explorer(app: Flask, repository: ActivityRepository) -> None:
         )
 
 
-def route_heatmap(app: Flask, repository: ActivityRepository) -> None:
-    heatmap_controller = HeatmapController(repository)
+def route_heatmap(
+    app: Flask, repository: ActivityRepository, tile_visit_accessor: TileVisitAccessor
+) -> None:
+    heatmap_controller = HeatmapController(repository, tile_visit_accessor)
 
     @app.route("/heatmap")
     def heatmap():
@@ -207,8 +216,10 @@ def route_search(app: Flask, repository: ActivityRepository) -> None:
         )
 
 
-def route_square_planner(app: Flask, repository: ActivityRepository) -> None:
-    controller = SquarePlannerController(repository)
+def route_square_planner(
+    app: Flask, repository: ActivityRepository, tile_visit_accessor: TileVisitAccessor
+) -> None:
+    controller = SquarePlannerController(repository, tile_visit_accessor)
 
     @app.route("/square-planner/<zoom>/<x>/<y>/<size>")
     def square_planner_planner(zoom, x, y, size):
@@ -303,7 +314,42 @@ def route_tiles(app: Flask, repository: ActivityRepository) -> None:
         )
 
 
-def webui_main(repository: ActivityRepository, host: str, port: int) -> None:
+def route_upload(
+    app: Flask,
+    repository: ActivityRepository,
+    tile_visit_accessor: TileVisitAccessor,
+    config: dict,
+):
+    upload_controller = UploadController(repository, tile_visit_accessor, config)
+
+    @app.route("/upload")
+    def form():
+        return render_template("upload.html.j2", **upload_controller.render_form())
+
+    @app.route("/upload/receive", methods=["POST"])
+    def receive():
+        return upload_controller.receive()
+
+
+def get_secret_key():
+    secret_file = pathlib.Path("Cache/flask-secret.json")
+    if secret_file.exists():
+        with open(secret_file) as f:
+            secret = json.load(f)
+    else:
+        secret = secrets.token_hex()
+        with open(secret_file, "w") as f:
+            json.dump(secret, f)
+    return secret
+
+
+def webui_main(
+    repository: ActivityRepository,
+    tile_visit_accessor: TileVisitAccessor,
+    config: dict,
+    host: str,
+    port: int,
+) -> None:
     app = Flask(__name__)
 
     route_activity(app, repository)
@@ -311,14 +357,18 @@ def webui_main(repository: ActivityRepository, host: str, port: int) -> None:
     route_config(app, repository)
     route_eddington(app, repository)
     route_equipment(app, repository)
-    route_explorer(app, repository)
-    route_heatmap(app, repository)
+    route_explorer(app, repository, tile_visit_accessor)
+    route_heatmap(app, repository, tile_visit_accessor)
     route_locations(app, repository)
     route_search(app, repository)
-    route_square_planner(app, repository)
+    route_square_planner(app, repository, tile_visit_accessor)
     route_start(app, repository)
     route_strava(app, host, port)
     route_summary(app, repository)
     route_tiles(app, repository)
+    route_upload(app, repository, tile_visit_accessor, config)
+
+    app.config["UPLOAD_FOLDER"] = "Activities"
+    app.secret_key = get_secret_key()
 
     app.run(host=host, port=port)

{geo_activity_playground-0.21.2 → geo_activity_playground-0.23.0}/geo_activity_playground/webui/calendar_controller.py

@@ -1,6 +1,5 @@
 import collections
 import datetime
-import functools
 
 from geo_activity_playground.core.activities import ActivityRepository
 
@@ -9,7 +8,6 @@ class CalendarController:
     def __init__(self, repository: ActivityRepository) -> None:
         self._repository = repository
 
-    @functools.cache
     def render_overview(self) -> dict:
         meta = self._repository.meta.copy()
         meta["date"] = meta["start"].dt.date
@@ -41,7 +39,6 @@ class CalendarController:
             "yearly_distances": yearly_distances,
         }
 
-    @functools.cache
     def render_month(self, year: int, month: int) -> dict:
         meta = self._repository.meta.copy()
         meta["date"] = meta["start"].dt.date

{geo_activity_playground-0.21.2 → geo_activity_playground-0.23.0}/geo_activity_playground/webui/eddington_controller.py

@@ -1,5 +1,3 @@
-import functools
-
 import altair as alt
 import numpy as np
 import pandas as pd
@@ -11,7 +9,6 @@ class EddingtonController:
     def __init__(self, repository: ActivityRepository) -> None:
         self._repository = repository
 
-    @functools.cache
     def render(self) -> dict:
         activities = self._repository.meta.copy()
         activities["day"] = [start.date() for start in activities["start"]]

{geo_activity_playground-0.21.2 → geo_activity_playground-0.23.0}/geo_activity_playground/webui/entry_controller.py

@@ -1,5 +1,4 @@
 import datetime
-import functools
 import itertools
 
 import altair as alt
@@ -13,7 +12,6 @@ class EntryController:
     def __init__(self, repository: ActivityRepository) -> None:
         self._repository = repository
 
-    @functools.cache
     def render(self) -> dict:
         result = {
             "distance_last_30_days_plot": distance_last_30_days_meta_plot(
@@ -22,7 +20,9 @@ class EntryController:
             "latest_activities": [],
         }
 
-        for activity in itertools.islice(self._repository.iter_activities(), 15):
+        for activity in itertools.islice(
+            self._repository.iter_activities(dropna=True), 15
+        ):
             time_series = self._repository.get_time_series(activity["id"])
             result["latest_activities"].append(
                 {

{geo_activity_playground-0.21.2 → geo_activity_playground-0.23.0}/geo_activity_playground/webui/equipment_controller.py

@@ -1,5 +1,3 @@
-import functools
-
 import altair as alt
 import pandas as pd
 
@@ -11,7 +9,6 @@ class EquipmentController:
     def __init__(self, repository: ActivityRepository) -> None:
         self._repository = repository
 
-    @functools.cache
     def render(self) -> dict:
         total_distances = (
             self._repository.meta.groupby("equipment")