geo-activity-playground 0.29.0__tar.gz → 0.34.1__tar.gz

{geo_activity_playground-0.29.0 → geo_activity_playground-0.34.1}/PKG-INFO

@@ -1,17 +1,17 @@
 Metadata-Version: 2.1
 Name: geo-activity-playground
-Version: 0.29.0
+Version: 0.34.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.10,<3.13
+Requires-Python: >=3.10,<3.14
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: Pillow (>=10.3.0,<11.0.0)
+Requires-Dist: Pillow (>=11.0.0,<12.0.0)
 Requires-Dist: altair (>=5.1.2,<6.0.0)
 Requires-Dist: appdirs (>=1.4.4,<2.0.0)
 Requires-Dist: charset-normalizer (>=3.3.2,<4.0.0)
@@ -22,12 +22,11 @@ Requires-Dist: geojson (>=3.0.1,<4.0.0)
 Requires-Dist: gpxpy (>=1.5.0,<2.0.0)
 Requires-Dist: jinja2 (>=3.1.2,<4.0.0)
 Requires-Dist: matplotlib (>=3.6.3,<4.0.0)
-Requires-Dist: numpy (>=1.22.4,<2.0.0)
+Requires-Dist: numpy (>=2.1.3,<3.0.0)
 Requires-Dist: pandas (>=2.2,<3.0)
-Requires-Dist: pyarrow (>=16.1.0,<17.0.0)
+Requires-Dist: pyarrow (>=18.1.0,<19.0.0)
 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 (>=2.0,<3.0)
 Requires-Dist: tcxreader (>=0.4.5,<0.5.0)

{geo_activity_playground-0.29.0 → geo_activity_playground-0.34.1}/geo_activity_playground/__main__.py

@@ -13,7 +13,7 @@ from geo_activity_playground.core.config import import_old_strava_config
 from geo_activity_playground.explorer.tile_visits import TileVisitAccessor
 from geo_activity_playground.explorer.video import explorer_video_main
 from geo_activity_playground.webui.app import web_ui_main
-from geo_activity_playground.webui.upload.controller import scan_for_activities
+from geo_activity_playground.webui.upload_blueprint import scan_for_activities
 
 logger = logging.getLogger(__name__)
 

{geo_activity_playground-0.29.0 → geo_activity_playground-0.34.1}/geo_activity_playground/core/activities.py

@@ -1,7 +1,9 @@
 import datetime
 import functools
+import json
 import logging
 import pickle
+from typing import Any
 from typing import Iterator
 from typing import Optional
 from typing import TypedDict
@@ -15,6 +17,7 @@ from tqdm import tqdm
 from geo_activity_playground.core.paths import activities_file
 from geo_activity_playground.core.paths import activity_enriched_meta_dir
 from geo_activity_playground.core.paths import activity_enriched_time_series_dir
+from geo_activity_playground.core.paths import activity_meta_override_dir
 
 logger = logging.getLogger(__name__)
 
@@ -82,13 +85,21 @@ def build_activity_meta() -> None:
     rows = []
     for new_id in tqdm(new_ids, desc="Register new activities"):
         with open(activity_enriched_meta_dir() / f"{new_id}.pickle", "rb") as f:
-            rows.append(pickle.load(f))
+            data = pickle.load(f)
+        override_file = activity_meta_override_dir() / f"{new_id}.json"
+        if override_file.exists():
+            with open(override_file) as f:
+                data.update(json.load(f))
+        rows.append(data)
 
     if rows:
         new_shard = pd.DataFrame(rows)
         new_shard.index = new_shard["id"]
         new_shard.index.name = "index"
-        meta = pd.concat([meta, new_shard])
+        if len(meta):
+            meta = pd.concat([meta, new_shard])
+        else:
+            meta = new_shard
 
     if len(meta):
         assert pd.api.types.is_dtype_equal(meta["start"].dtype, "datetime64[ns]"), (
@@ -103,7 +114,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 +127,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]:
@@ -140,7 +147,6 @@ class ActivityRepository:
             if not dropna or not pd.isna(row["start"]):
                 yield row
 
-    @functools.lru_cache()
     def get_activity_by_id(self, id: int) -> ActivityMeta:
         activity = self.meta.loc[id]
         assert isinstance(activity["name"], str), activity["name"]
@@ -158,6 +164,9 @@ class ActivityRepository:
 
         return df
 
+    def save(self) -> None:
+        self.meta.to_parquet(activities_file())
+
 
 def make_geojson_from_time_series(time_series: pd.DataFrame) -> str:
     fc = geojson.FeatureCollection(
@@ -198,7 +207,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.29.0 → geo_activity_playground-0.34.1}/geo_activity_playground/core/config.py

@@ -21,14 +21,17 @@ logger = logging.getLogger(__name__)
 @dataclasses.dataclass
 class Config:
     birth_year: Optional[int] = None
-    color_scheme_for_counts: str = "viridis"
+    color_scheme_for_counts: str = "teals"
     color_scheme_for_kind: str = "category10"
+    color_scheme_for_heatmap: str = "hot"
     equipment_offsets: dict[str, float] = dataclasses.field(default_factory=dict)
     explorer_zoom_levels: list[int] = dataclasses.field(
         default_factory=lambda: [14, 17]
     )
     heart_rate_resting: int = 0
     heart_rate_maximum: Optional[int] = None
+    ignore_suffixes: list[str] = dataclasses.field(default_factory=list)
+    kind_renames: dict[str, str] = dataclasses.field(default_factory=dict)
     kinds_without_achievements: list[str] = dataclasses.field(default_factory=list)
     metadata_extraction_regexes: list[str] = dataclasses.field(default_factory=list)
     num_processes: Optional[int] = 1
@@ -39,7 +42,10 @@ class Config:
     strava_client_id: int = 131693
     strava_client_secret: str = "0ccc0100a2c218512a7ef0cea3b0e322fb4b4365"
     strava_client_code: Optional[str] = None
+    time_diff_threshold_seconds: Optional[int] = 30
     upload_password: Optional[str] = None
+    map_tile_url: str = "https://tile.openstreetmap.org/{zoom}/{x}/{y}.png"
+    map_tile_attribution: str = '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a> | <a href="https://www.openstreetmap.org/fixthemap">Correct Map</a>'
 
 
 class ConfigAccessor:

{geo_activity_playground-0.29.0 → geo_activity_playground-0.34.1}/geo_activity_playground/core/enrichment.py

@@ -82,11 +82,15 @@ def enrich_activities(config: Config) -> None:
             )
             continue
 
+        # Rename kinds if needed.
+        if metadata["kind"] in config.kind_renames:
+            metadata["kind"] = config.kind_renames[metadata["kind"]]
+
         # Enrich time series.
         if metadata["kind"] in config.kinds_without_achievements:
             metadata["consider_for_achievements"] = False
         time_series = _embellish_single_time_series(
-            time_series, metadata.get("start", None)
+            time_series, metadata.get("start", None), config.time_diff_threshold_seconds
         )
         metadata.update(_get_metadata_from_timeseries(time_series))
 
@@ -131,7 +135,9 @@ def _compute_moving_time(time_series: pd.DataFrame) -> datetime.timedelta:
 
 
 def _embellish_single_time_series(
-    timeseries: pd.DataFrame, start: Optional[datetime.datetime] = None
+    timeseries: pd.DataFrame,
+    start: Optional[datetime.datetime],
+    time_diff_threshold_seconds: int,
 ) -> pd.DataFrame:
     if start is not None and pd.api.types.is_dtype_equal(
         timeseries["time"].dtype, "int64"
@@ -153,10 +159,12 @@ def _embellish_single_time_series(
         timeseries["latitude"],
         timeseries["longitude"],
     ).fillna(0.0)
-    time_diff_threshold_seconds = 30
-    time_diff = (timeseries["time"] - timeseries["time"].shift(1)).dt.total_seconds()
-    jump_indices = time_diff >= time_diff_threshold_seconds
-    distances.loc[jump_indices] = 0.0
+    if time_diff_threshold_seconds:
+        time_diff = (
+            timeseries["time"] - timeseries["time"].shift(1)
+        ).dt.total_seconds()
+        jump_indices = time_diff >= time_diff_threshold_seconds
+        distances.loc[jump_indices] = 0.0
 
     if "distance_km" not in timeseries.columns:
         timeseries["distance_km"] = pd.Series(np.cumsum(distances)) / 1000
@@ -173,7 +181,10 @@ def _embellish_single_time_series(
         timeseries = timeseries.loc[~potential_jumps].copy()
 
     if "segment_id" not in timeseries.columns:
-        timeseries["segment_id"] = np.cumsum(jump_indices)
+        if time_diff_threshold_seconds:
+            timeseries["segment_id"] = np.cumsum(jump_indices)
+        else:
+            timeseries["segment_id"] = 0
 
     if "x" not in timeseries.columns:
         x, y = compute_tile_float(timeseries["latitude"], timeseries["longitude"], 0)

{geo_activity_playground-0.29.0 → geo_activity_playground-0.34.1}/geo_activity_playground/core/heatmap.py

@@ -6,6 +6,7 @@ import logging
 
 import numpy as np
 
+from geo_activity_playground.core.config import Config
 from geo_activity_playground.core.tiles import compute_tile_float
 from geo_activity_playground.core.tiles import get_tile
 from geo_activity_playground.core.tiles import get_tile_upper_left_lat_lon
@@ -123,21 +124,66 @@ def get_sensible_zoom_level(
     )
 
 
-def build_map_from_tiles(tile_bounds: TileBounds) -> np.ndarray:
-    background = np.zeros((*PixelBounds.from_tile_bounds(tile_bounds).shape, 3))
-
-    for x in range(tile_bounds.x_tile_min, tile_bounds.x_tile_max):
-        for y in range(tile_bounds.y_tile_min, tile_bounds.y_tile_max):
-            tile = np.array(get_tile(tile_bounds.zoom, x, y)) / 255
-
-            i = y - tile_bounds.y_tile_min
-            j = x - tile_bounds.x_tile_min
-
-            background[
-                i * OSM_TILE_SIZE : (i + 1) * OSM_TILE_SIZE,
-                j * OSM_TILE_SIZE : (j + 1) * OSM_TILE_SIZE,
-                :,
-            ] = tile[:, :, :3]
+def build_map_from_tiles_around_center(
+    center: tuple[float, float],
+    zoom: int,
+    target: tuple[int, int],
+    inner_target: tuple[int, int],
+    config: Config,
+) -> np.ndarray:
+    background = np.zeros((target[1], target[0], 3))
+
+    # We will work with the center point and have it in terms of tiles `t` and also in terms of pixels `p`. At the start we know that the tile center must be in the middle of the image.
+    t = np.array(center)
+    p = np.array([inner_target[0] / 2, inner_target[1] / 2])
+
+    # Shift both such that they are in the top-left corner of an even tile.
+    t_offset = np.array([center[0] % 1, center[1] % 1])
+    t -= t_offset
+    p -= t_offset * OSM_TILE_SIZE
+
+    # Shift until we have left the image.
+    shift = np.ceil(p / OSM_TILE_SIZE)
+    p -= shift * OSM_TILE_SIZE
+    t -= shift
+
+    num_tiles = np.ceil(np.array(target) / OSM_TILE_SIZE) + 1
+
+    for x in range(int(t[0]), int(t[0] + num_tiles[0])):
+        for y in range(int(t[1]), int(t[1]) + int(num_tiles[1])):
+            source_x_min = 0
+            source_y_min = 0
+            source_x_max = source_x_min + OSM_TILE_SIZE
+            source_y_max = source_y_min + OSM_TILE_SIZE
+
+            target_x_min = (x - int(t[0])) * OSM_TILE_SIZE + int(p[0])
+            target_y_min = (y - int(t[1])) * OSM_TILE_SIZE + int(p[1])
+            target_x_max = target_x_min + OSM_TILE_SIZE
+            target_y_max = target_y_min + OSM_TILE_SIZE
+
+            if target_x_min < 0:
+                source_x_min -= target_x_min
+                target_x_min = 0
+            if target_y_min < 0:
+                source_y_min -= target_y_min
+                target_y_min = 0
+            if target_x_max > target[0]:
+                a = target_x_max - target[0]
+                target_x_max -= a
+                source_x_max -= a
+            if target_y_max > target[1]:
+                a = target_y_max - target[1]
+                target_y_max -= a
+                source_y_max -= a
+
+            if source_x_max < 0 or source_y_max < 0:
+                continue
+
+            tile = np.array(get_tile(zoom, x, y, config.map_tile_url)) / 255
+
+            background[target_y_min:target_y_max, target_x_min:target_x_max] = tile[
+                source_y_min:source_y_max, source_x_min:source_x_max, :3
+            ]
 
     return background
 

{geo_activity_playground-0.29.0 → geo_activity_playground-0.34.1}/geo_activity_playground/core/paths.py

@@ -8,7 +8,6 @@ import typing
 
 
 def dir_wrapper(path: pathlib.Path) -> typing.Callable[[], pathlib.Path]:
-    @functools.cache
     def wrapper() -> pathlib.Path:
         path.mkdir(exist_ok=True, parents=True)
         return path
@@ -17,7 +16,6 @@ def dir_wrapper(path: pathlib.Path) -> typing.Callable[[], pathlib.Path]:
 
 
 def file_wrapper(path: pathlib.Path) -> typing.Callable[[], pathlib.Path]:
-    @functools.cache
     def wrapper() -> pathlib.Path:
         path.parent.mkdir(exist_ok=True, parents=True)
         return path
@@ -55,6 +53,8 @@ _strava_last_activity_date_path = _cache_dir / "strava-last-activity-date.json"
 
 _new_config_file = pathlib.Path("config.json")
 
+_activity_meta_override_dir = pathlib.Path("Metadata Override")
+
 
 cache_dir = dir_wrapper(_cache_dir)
 
@@ -65,6 +65,7 @@ activity_enriched_meta_dir = dir_wrapper(_activity_enriched_meta_dir)
 activity_enriched_time_series_dir = dir_wrapper(_activity_enriched_time_series_dir)
 tiles_per_time_series = dir_wrapper(_tiles_per_time_series)
 strava_api_dir = dir_wrapper(_strava_api_dir)
+activity_meta_override_dir = dir_wrapper(_activity_meta_override_dir)
 
 activities_file = file_wrapper(_activities_file)
 strava_dynamic_config_path = file_wrapper(_strava_dynamic_config_path)

{geo_activity_playground-0.29.0 → geo_activity_playground-0.34.1}/geo_activity_playground/core/tiles.py

@@ -3,6 +3,7 @@ import logging
 import math
 import pathlib
 import time
+import urllib.parse
 from typing import Iterator
 from typing import Optional
 
@@ -13,8 +14,10 @@ from PIL import Image
 logger = logging.getLogger(__name__)
 
 
-def osm_tile_path(x: int, y: int, zoom: int) -> pathlib.Path:
-    path = pathlib.Path("Open Street Map Tiles") / f"{zoom}/{x}/{y}.png"
+def osm_tile_path(x: int, y: int, zoom: int, url_template: str) -> pathlib.Path:
+    base_dir = pathlib.Path("Open Street Map Tiles")
+    dir_for_source = base_dir / urllib.parse.quote_plus(url_template)
+    path = dir_for_source / f"{zoom}/{x}/{y}.png"
     path.parent.mkdir(parents=True, exist_ok=True)
     return path
 
@@ -62,11 +65,11 @@ def download_file(url: str, destination: pathlib.Path):
 
 
 @functools.lru_cache()
-def get_tile(zoom: int, x: int, y: int) -> Image.Image:
-    destination = osm_tile_path(x, y, zoom)
+def get_tile(zoom: int, x: int, y: int, url_template: str) -> Image.Image:
+    destination = osm_tile_path(x, y, zoom, url_template)
     if not destination.exists():
         logger.info(f"Downloading OSM tile {x=}, {y=}, {zoom=} …")
-        url = f"https://tile.openstreetmap.org/{zoom}/{x}/{y}.png"
+        url = url_template.format(x=x, y=y, zoom=zoom)
         download_file(url, destination)
     with Image.open(destination) as image:
         image.load()

{geo_activity_playground-0.29.0 → geo_activity_playground-0.34.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.29.0 → geo_activity_playground-0.34.1}/geo_activity_playground/explorer/tile_visits.py

@@ -59,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
@@ -165,7 +165,7 @@ def _process_activity(
     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": [],

{geo_activity_playground-0.29.0 → geo_activity_playground-0.34.1}/geo_activity_playground/explorer/video.py

@@ -9,13 +9,14 @@ from typing import Tuple
 
 import numpy as np
 import pandas as pd
-import scipy.interpolate
 from PIL import Image
 from PIL import ImageEnhance
 from tqdm import tqdm
 
 from ..core.tiles import get_tile
 
+# import scipy.interpolate
+
 
 def build_image(
     center_x: float,

{geo_activity_playground-0.29.0 → geo_activity_playground-0.34.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.29.0 → geo_activity_playground-0.34.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.29.0 → geo_activity_playground-0.34.1}/geo_activity_playground/importers/directory.py

@@ -10,6 +10,7 @@ from typing import Optional
 from tqdm import tqdm
 
 from geo_activity_playground.core.activities import ActivityMeta
+from geo_activity_playground.core.config import Config
 from geo_activity_playground.core.paths import activity_extracted_dir
 from geo_activity_playground.core.paths import activity_extracted_meta_dir
 from geo_activity_playground.core.paths import activity_extracted_time_series_dir
@@ -24,13 +25,16 @@ ACTIVITY_DIR = pathlib.Path("Activities")
 
 
 def import_from_directory(
-    metadata_extraction_regexes: list[str], num_processes: Optional[int]
+    metadata_extraction_regexes: list[str], num_processes: Optional[int], config: Config
 ) -> None:
 
     activity_paths = [
         path
         for path in ACTIVITY_DIR.rglob("*.*")
-        if path.is_file() and path.suffixes and not path.stem.startswith(".")
+        if path.is_file()
+        and path.suffixes
+        and not path.stem.startswith(".")
+        and not path.suffix in config.ignore_suffixes
     ]
     work_tracker = WorkTracker(activity_extracted_dir() / "work-tracker-extract.pickle")
     new_activity_paths = work_tracker.filter(activity_paths)
@@ -126,11 +130,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.29.0 → geo_activity_playground-0.34.1}/geo_activity_playground/importers/strava_api.py

@@ -137,9 +137,9 @@ def try_import_strava(config: Config) -> bool:
                     **{
                         "id": activity.id,
                         "commute": activity.commute,
-                        "distance_km": activity.distance.magnitude / 1000,
+                        "distance_km": activity.distance / 1000,
                         "name": activity.name,
-                        "kind": str(activity.type),
+                        "kind": str(activity.type.root),
                         "start": convert_to_datetime_ns(activity.start_date),
                         "elapsed_time": activity.elapsed_time,
                         "equipment": gear_names[activity.gear_id],

{geo_activity_playground-0.29.0 → geo_activity_playground-0.34.1}/geo_activity_playground/importers/strava_checkout.py

@@ -146,7 +146,7 @@ def float_with_comma_or_period(x: str) -> Optional[float]:
 
 def import_from_strava_checkout() -> None:
     checkout_path = pathlib.Path("Strava Export")
-    with open(checkout_path / "activities.csv") as f:
+    with open(checkout_path / "activities.csv", encoding="utf-8") as f:
         rows = parse_csv(f.read())
     header = rows[0]
 
@@ -159,9 +159,15 @@ def import_from_strava_checkout() -> None:
 
     if header[0] == EXPECTED_COLUMNS[0]:
         dayfirst = False
-    if header[0] == "Aktivitäts-ID":
+    elif header[0] == "Aktivitäts-ID":
         header = EXPECTED_COLUMNS
         dayfirst = True
+    else:
+        logger.error(
+            f"You are trying to import a Strava checkout where the `activities.csv` contains an unexpected header format. In order to import this, we need to map these to the English ones. Unfortunately Strava often changes the number of 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(header)
+        sys.exit(1)
 
     table = {
         header[i]: [rows[r][i] for r in range(1, len(rows))] for i in range(len(header))