geo-activity-playground 0.24.2__py3-none-any.whl → 0.26.0__py3-none-any.whl

geo_activity_playground/explorer/tile_visits.py

@@ -7,12 +7,15 @@ import pickle
 from typing import Any
 from typing import Iterator
 from typing import Optional
+from typing import TypedDict
 
 import pandas as pd
 from tqdm import tqdm
 
 from geo_activity_playground.core.activities import ActivityRepository
+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
 from geo_activity_playground.core.tasks import WorkTracker
 from geo_activity_playground.core.tiles import adjacent_to
 from geo_activity_playground.core.tiles import interpolate_missing_tile
@@ -21,6 +24,12 @@ from geo_activity_playground.core.tiles import interpolate_missing_tile
 logger = logging.getLogger(__name__)
 
 
+class TileHistoryRow(TypedDict):
+    time: datetime.datetime
+    tile_x: int
+    tile_y: int
+
+
 class TileVisitAccessor:
     TILE_EVOLUTION_STATES_PATH = pathlib.Path("Cache/tile-evolution-state.pickle")
     TILE_HISTORIES_PATH = pathlib.Path(f"Cache/tile-history.pickle")
@@ -64,60 +73,87 @@ class TileVisitAccessor:
 def compute_tile_visits(
     repository: ActivityRepository, tile_visits_accessor: TileVisitAccessor
 ) -> None:
+    present_activity_ids = repository.get_activity_ids()
+    work_tracker = WorkTracker(work_tracker_path("tile-visits"))
+
+    changed_zoom_tile = collections.defaultdict(set)
+
+    # Delete visits from removed activities.
+    for zoom, activities_per_tile in tile_visits_accessor.activities_per_tile.items():
+        for tile, activity_ids in activities_per_tile.items():
+            deleted_ids = activity_ids - present_activity_ids
+            if deleted_ids:
+                logger.debug(
+                    f"Removing activities {deleted_ids} from tile {tile} at {zoom=}."
+                )
+                for activity_id in deleted_ids:
+                    activity_ids.remove(activity_id)
+                    work_tracker.discard(activity_id)
+                    changed_zoom_tile[zoom].add(tile)
 
-    work_tracker = WorkTracker("tile-visits")
+    # Add visits from new activities.
     activity_ids_to_process = work_tracker.filter(repository.get_activity_ids())
-    new_tile_history_rows = collections.defaultdict(list)
     for activity_id in tqdm(
         activity_ids_to_process, desc="Extract explorer tile visits"
     ):
-        time_series = repository.get_time_series(activity_id)
         for zoom in range(20):
-            for time, tile_x, tile_y in _tiles_from_points(time_series, zoom):
+            for time, tile_x, tile_y in _tiles_from_points(
+                repository.get_time_series(activity_id), zoom
+            ):
                 tile = (tile_x, tile_y)
-                if not tile in tile_visits_accessor.activities_per_tile[zoom]:
+                if tile not in tile_visits_accessor.activities_per_tile[zoom]:
                     tile_visits_accessor.activities_per_tile[zoom][tile] = set()
                 tile_visits_accessor.activities_per_tile[zoom][tile].add(activity_id)
-
-                activity = repository.get_activity_by_id(activity_id)
-                if activity["consider_for_achievements"]:
-                    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
-                        if d["last_time"] < time:
-                            d["last_time"] = time
-                            d["last_id"] = activity_id
-                        d["activity_ids"].add(activity_id)
-                    else:
-                        tile_visits_accessor.visits[zoom][tile] = {
-                            "first_time": time,
-                            "first_id": activity_id,
-                            "last_time": time,
-                            "last_id": activity_id,
-                            "activity_ids": {activity_id},
-                        }
-                        new_tile_history_rows[zoom].append(
-                            {
-                                "activity_id": activity_id,
-                                "time": time,
-                                "tile_x": tile_x,
-                                "tile_y": tile_y,
-                            }
-                        )
+                changed_zoom_tile[zoom].add(tile)
         work_tracker.mark_done(activity_id)
 
-    if new_tile_history_rows:
-        for zoom, new_rows in new_tile_history_rows.items():
-            new_df = pd.DataFrame(new_rows)
-            new_df.sort_values("time", inplace=True)
-            tile_visits_accessor.histories[zoom] = pd.concat(
-                [tile_visits_accessor.histories[zoom], new_df]
-            )
-
-        tile_visits_accessor.save()
+    # Update tile visits structure.
+    for zoom, changed_tiles in tqdm(
+        changed_zoom_tile.items(), desc="Incorporate changes in tiles"
+    ):
+        soa = {"activity_id": [], "time": [], "tile_x": [], "tile_y": []}
+
+        for tile in changed_tiles:
+            activity_ids = tile_visits_accessor.activities_per_tile[zoom][tile]
+            activities = [
+                repository.get_activity_by_id(activity_id)
+                for activity_id in activity_ids
+            ]
+            activities_to_consider = [
+                activity
+                for activity in activities
+                if activity["consider_for_achievements"]
+            ]
+            activities_to_consider.sort(key=lambda activity: activity["start"])
+
+            if activities_to_consider:
+                tile_visits_accessor.visits[zoom][tile] = {
+                    "first_time": activities_to_consider[0]["start"],
+                    "first_id": activities_to_consider[0]["id"],
+                    "last_time": activities_to_consider[-1]["start"],
+                    "last_id": activities_to_consider[-1]["id"],
+                    "activity_ids": {
+                        activity["id"] for activity in activities_to_consider
+                    },
+                }
+
+                soa["activity_id"].append(activities_to_consider[0]["id"])
+                soa["time"].append(activities_to_consider[0]["start"])
+                soa["tile_x"].append(tile[0])
+                soa["tile_y"].append(tile[1])
+            else:
+                if tile in tile_visits_accessor.visits[zoom]:
+                    del tile_visits_accessor.visits[zoom][tile]
+
+        df = pd.DataFrame(soa)
+        if len(df) > 0:
+            df = pd.concat([tile_visits_accessor.histories[zoom], df])
+            df.sort_values("time", inplace=True)
+            tile_visits_accessor.histories[zoom] = df.groupby(
+                ["tile_x", "tile_y"]
+            ).head(1)
 
+    tile_visits_accessor.save()
     work_tracker.close()
 
 

geo_activity_playground/{core → importers}/activity_parsers.py

@@ -7,13 +7,13 @@ import xml
 import charset_normalizer
 import dateutil.parser
 import fitdecode
+import fitdecode.exceptions
 import gpxpy
 import pandas as pd
 import tcxreader.tcxreader
 import xmltodict
 
 from geo_activity_playground.core.activities import ActivityMeta
-from geo_activity_playground.core.activities import embellish_single_time_series
 from geo_activity_playground.core.time_conversion import convert_to_datetime_ns
 
 logger = logging.getLogger(__name__)
@@ -42,7 +42,12 @@ def read_activity(path: pathlib.Path) -> tuple[ActivityMeta, pd.DataFrame]:
         except UnicodeDecodeError as e:
             raise ActivityParseError(f"Encoding issue") from e
     elif file_type == ".fit":
-        metadata, timeseries = read_fit_activity(path, opener)
+        try:
+            metadata, timeseries = read_fit_activity(path, opener)
+        except fitdecode.exceptions.FitError as e:
+            raise ActivityParseError(f"Error in FIT file") from e
+        except KeyError as e:
+            raise ActivityParseError(f"Key error while parsing FIT file") from e
     elif file_type == ".tcx":
         try:
             timeseries = read_tcx_activity(path, opener)
@@ -55,18 +60,6 @@ def read_activity(path: pathlib.Path) -> tuple[ActivityMeta, pd.DataFrame]:
     else:
         raise ActivityParseError(f"Unsupported file format: {file_type}")
 
-    if len(timeseries):
-        timeseries, changed = embellish_single_time_series(timeseries)
-
-        # Extract some meta data from the time series.
-        metadata["start"] = timeseries["time"].iloc[0]
-        metadata["elapsed_time"] = (
-            timeseries["time"].iloc[-1] - timeseries["time"].iloc[0]
-        )
-        metadata["distance_km"] = timeseries["distance_km"].iloc[-1]
-        if "calories" in timeseries.columns:
-            metadata["calories"] = timeseries["calories"].iloc[-1]
-
     return metadata, timeseries
 
 

geo_activity_playground/importers/directory.py

@@ -4,44 +4,58 @@ import multiprocessing
 import pathlib
 import pickle
 import re
-import sys
 import traceback
-from typing import Any
 from typing import Optional
 
-import pandas as pd
 from tqdm import tqdm
 
 from geo_activity_playground.core.activities import ActivityMeta
-from geo_activity_playground.core.activities import ActivityRepository
-from geo_activity_playground.core.activity_parsers import ActivityParseError
-from geo_activity_playground.core.activity_parsers import read_activity
+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
+from geo_activity_playground.core.tasks import stored_object
 from geo_activity_playground.core.tasks import WorkTracker
+from geo_activity_playground.importers.activity_parsers import ActivityParseError
+from geo_activity_playground.importers.activity_parsers import read_activity
 
 logger = logging.getLogger(__name__)
 
 ACTIVITY_DIR = pathlib.Path("Activities")
 
 
-def import_from_directory(
-    repository: ActivityRepository,
-    kind_defaults: dict[str, Any] = {},
-    metadata_extraction_regexes: list[str] = [],
-) -> None:
-    paths_with_errors = []
-    work_tracker = WorkTracker("parse-activity-files")
+def import_from_directory(metadata_extraction_regexes: list[str] = []) -> None:
 
     activity_paths = [
         path
         for path in ACTIVITY_DIR.rglob("*.*")
         if path.is_file() and path.suffixes and not path.stem.startswith(".")
     ]
+    work_tracker = WorkTracker(activity_extracted_dir() / "work-tracker-extract.pickle")
     new_activity_paths = work_tracker.filter(activity_paths)
 
-    activity_stream_dir = pathlib.Path("Cache/Activity Timeseries")
-    activity_stream_dir.mkdir(exist_ok=True, parents=True)
-    file_metadata_dir = pathlib.Path("Cache/Activity Metadata")
-    file_metadata_dir.mkdir(exist_ok=True, parents=True)
+    with stored_object(
+        activity_extracted_dir() / "file-hashes.pickle", {}
+    ) as file_hashes:
+        for path in tqdm(new_activity_paths, desc="Detect deleted activities"):
+            file_hashes[path] = get_file_hash(path)
+
+        deleted_files = set(file_hashes.keys()) - set(activity_paths)
+        deleted_hashes = [file_hashes[path] for path in deleted_files]
+        for deleted_hash in deleted_hashes:
+            activity_extracted_meta_path = (
+                activity_extracted_meta_dir() / f"{deleted_hash}.pickle"
+            )
+            activity_extracted_time_series_path = (
+                activity_extracted_time_series_dir() / f"{deleted_hash}.parquet"
+            )
+            logger.warning(f"Deleting {activity_extracted_meta_path}")
+            logger.warning(f"Deleting {activity_extracted_time_series_path}")
+            activity_extracted_meta_path.unlink(missing_ok=True)
+            activity_extracted_time_series_path.unlink(missing_ok=True)
+        for deleted_file in deleted_files:
+            logger.warning(f"Deleting {deleted_file}")
+            del file_hashes[deleted_file]
+            work_tracker.discard(deleted_file)
 
     with multiprocessing.Pool() as pool:
         paths_with_errors = tqdm(
@@ -53,7 +67,7 @@ def import_from_directory(
 
     for path in tqdm(new_activity_paths, desc="Collate activity metadata"):
         activity_id = get_file_hash(path)
-        file_metadata_path = file_metadata_dir / f"{activity_id}.pickle"
+        file_metadata_path = activity_extracted_meta_dir() / f"{activity_id}.pickle"
         work_tracker.mark_done(path)
 
         if not file_metadata_path.exists():
@@ -73,8 +87,8 @@ def import_from_directory(
         )
         activity_meta.update(activity_meta_from_file)
         activity_meta.update(_get_metadata_from_path(path, metadata_extraction_regexes))
-        activity_meta.update(kind_defaults.get(activity_meta["kind"], {}))
-        repository.add_activity(activity_meta)
+        with open(file_metadata_path, "wb") as f:
+            pickle.dump(activity_meta, f)
 
     if paths_with_errors:
         logger.warning(
@@ -83,18 +97,13 @@ def import_from_directory(
         for path, error in paths_with_errors:
             logger.error(f"{path}: {error}")
 
-    repository.commit()
-
     work_tracker.close()
 
 
 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)
-    timeseries_path = activity_stream_dir / f"{activity_id}.parquet"
-    file_metadata_path = file_metadata_dir / f"{activity_id}.pickle"
+    timeseries_path = activity_extracted_time_series_dir() / f"{activity_id}.parquet"
+    file_metadata_path = activity_extracted_meta_dir() / f"{activity_id}.pickle"
 
     if not timeseries_path.exists():
         try:

geo_activity_playground/importers/strava_api.py

@@ -14,9 +14,13 @@ from stravalib.exc import ObjectNotFound
 from stravalib.exc import RateLimitExceeded
 from tqdm import tqdm
 
-from geo_activity_playground.core.activities import ActivityRepository
+from geo_activity_playground.core.activities import ActivityMeta
 from geo_activity_playground.core.config import get_config
+from geo_activity_playground.core.paths import activity_extracted_meta_dir
+from geo_activity_playground.core.paths import activity_extracted_time_series_dir
 from geo_activity_playground.core.paths import cache_dir
+from geo_activity_playground.core.paths import strava_api_dir
+from geo_activity_playground.core.paths import strava_dynamic_config_path
 from geo_activity_playground.core.time_conversion import convert_to_datetime_ns
 
 
@@ -35,31 +39,22 @@ def set_state(path: pathlib.Path, state: Any) -> None:
         json.dump(state, f, indent=2, sort_keys=True, ensure_ascii=False)
 
 
-@functools.cache
-def strava_api_dir() -> pathlib.Path:
-    result = pathlib.Path.cwd() / "Strava API"
-    result.mkdir(exist_ok=True, parents=True)
-    return result
-
-
-@functools.cache
-def activity_stream_dir() -> pathlib.Path:
-    path = pathlib.Path("Cache/Activity Timeseries")
-    path.mkdir(exist_ok=True, parents=True)
-    return path
-
-
 def get_current_access_token() -> str:
-    config = get_config()
+    if strava_dynamic_config_path().exists():
+        with open(strava_dynamic_config_path()) as f:
+            strava_config = json.load(f)
+    else:
+        config = get_config()
+        strava_config = config["strava"]
 
     tokens = get_state(strava_api_dir() / "strava_tokens.json")
     if not tokens:
         logger.info("Create Strava access token …")
         client = Client()
         token_response = client.exchange_code_for_token(
-            client_id=config["strava"]["client_id"],
-            client_secret=config["strava"]["client_secret"],
-            code=config["strava"]["code"],
+            client_id=strava_config["client_id"],
+            client_secret=strava_config["client_secret"],
+            code=strava_config["code"],
         )
         tokens = {
             "access": token_response["access_token"],
@@ -71,8 +66,8 @@ def get_current_access_token() -> str:
         logger.info("Renew Strava access token …")
         client = Client()
         token_response = client.refresh_access_token(
-            client_id=config["strava"]["client_id"],
-            client_secret=config["strava"]["client_secret"],
+            client_id=strava_config["client_id"],
+            client_secret=strava_config["client_secret"],
             refresh_token=tokens["refresh"],
         )
         tokens = {
@@ -94,8 +89,8 @@ def round_to_next_quarter_hour(date: datetime.datetime) -> datetime.datetime:
     return next_quarter
 
 
-def import_from_strava_api(repository: ActivityRepository) -> None:
-    while try_import_strava(repository):
+def import_from_strava_api() -> None:
+    while try_import_strava():
         now = datetime.datetime.now()
         next_quarter = round_to_next_quarter_hour(now)
         seconds_to_wait = (next_quarter - now).total_seconds() + 10
@@ -105,12 +100,13 @@ def import_from_strava_api(repository: ActivityRepository) -> None:
         time.sleep(seconds_to_wait)
 
 
-def try_import_strava(repository: ActivityRepository) -> bool:
-    last = repository.last_activity_date()
-    if last is None:
-        get_after = "2000-01-01T00:00:00Z"
+def try_import_strava() -> bool:
+    last_activity_date_path = cache_dir() / "strava-last-activity-date.json"
+    if last_activity_date_path.exists():
+        with open(last_activity_date_path) as f:
+            get_after = json.load(f)
     else:
-        get_after = last.isoformat().replace("+00:00", "Z")
+        get_after = "2000-01-01T00:00:00Z"
 
     gear_names = {None: "None"}
 
@@ -120,22 +116,26 @@ def try_import_strava(repository: ActivityRepository) -> bool:
         for activity in tqdm(
             client.get_activities(after=get_after), desc="Downloading Strava activities"
         ):
-            # Sometimes we still get an activity here although it has already been imported from the Strava checkout.
-            if repository.has_activity(activity.id):
-                continue
             cache_file = (
-                pathlib.Path("Cache") / "Activity Metadata" / f"{activity.id}.pickle"
+                pathlib.Path("Cache")
+                / "Strava Activity Metadata"
+                / f"{activity.id}.pickle"
             )
+            # Sometimes we still get an activity here although it has already been imported from the Strava checkout.
+            if cache_file.exists():
+                continue
             cache_file.parent.mkdir(exist_ok=True, parents=True)
             with open(cache_file, "wb") as f:
                 pickle.dump(activity, f)
-            if not activity.gear_id in gear_names:
+            if activity.gear_id not in gear_names:
                 gear = client.get_gear(activity.gear_id)
                 gear_names[activity.gear_id] = (
                     f"{gear.name}" or f"{gear.brand_name} {gear.model_name}"
                 )
 
-            time_series_path = activity_stream_dir() / f"{activity.id}.parquet"
+            time_series_path = (
+                activity_extracted_time_series_dir() / f"{activity.id}.parquet"
+            )
             if time_series_path.exists():
                 time_series = pd.read_parquet(time_series_path)
             else:
@@ -159,8 +159,8 @@ def try_import_strava(repository: ActivityRepository) -> bool:
             detailed_activity = get_detailed_activity(activity.id, client)
 
             if len(time_series) > 0 and "latitude" in time_series.columns:
-                repository.add_activity(
-                    {
+                activity_meta = ActivityMeta(
+                    **{
                         "id": activity.id,
                         "commute": activity.commute,
                         "distance_km": activity.distance.magnitude / 1000,
@@ -170,8 +170,17 @@ def try_import_strava(repository: ActivityRepository) -> bool:
                         "elapsed_time": activity.elapsed_time,
                         "equipment": gear_names[activity.gear_id],
                         "calories": detailed_activity.calories,
+                        "moving_time": activity.moving_time,
                     }
                 )
+                with open(
+                    activity_extracted_meta_dir() / f"{activity.id}.pickle", "wb"
+                ) as f:
+                    pickle.dump(activity_meta, f)
+
+            with open(last_activity_date_path, "w") as f:
+                json.dump(activity.start_date.isoformat().replace("+00:00", "Z"), f)
+
         limit_exceeded = False
     except RateLimitExceeded:
         limit_exceeded = True
@@ -181,8 +190,6 @@ def try_import_strava(repository: ActivityRepository) -> bool:
         else:
             raise
 
-    repository.commit()
-
     return limit_exceeded
 
 

geo_activity_playground/importers/strava_checkout.py

@@ -1,6 +1,7 @@
 import datetime
 import logging
 import pathlib
+import pickle
 import shutil
 import sys
 import traceback
@@ -12,11 +13,13 @@ import numpy as np
 import pandas as pd
 from tqdm import tqdm
 
-from geo_activity_playground.core.activities import ActivityRepository
-from geo_activity_playground.core.activity_parsers import ActivityParseError
-from geo_activity_playground.core.activity_parsers import read_activity
+from geo_activity_playground.core.paths import activity_extracted_meta_dir
+from geo_activity_playground.core.paths import activity_extracted_time_series_dir
+from geo_activity_playground.core.tasks import work_tracker_path
 from geo_activity_playground.core.tasks import WorkTracker
 from geo_activity_playground.core.time_conversion import convert_to_datetime_ns
+from geo_activity_playground.importers.activity_parsers import ActivityParseError
+from geo_activity_playground.importers.activity_parsers import read_activity
 
 
 logger = logging.getLogger(__name__)
@@ -116,6 +119,13 @@ EXPECTED_COLUMNS = [
     "Newly Explored Dirt Distance",
     "Activity Count",
     "Total Steps",
+    "Carbon Saved",
+    "Pool Length",
+    "Training Load",
+    "Intensity",
+    "Average Grade Adjusted Pace",
+    "Timer Time",
+    "Total Cycles",
     "Media",
 ]
 
@@ -127,7 +137,7 @@ def float_or_none(x: Union[float, str]) -> Optional[float]:
         return None
 
 
-def import_from_strava_checkout(repository: ActivityRepository) -> None:
+def import_from_strava_checkout() -> None:
     checkout_path = pathlib.Path("Strava Export")
     activities = pd.read_csv(checkout_path / "activities.csv")
 
@@ -146,19 +156,20 @@ def import_from_strava_checkout(repository: ActivityRepository) -> None:
         dayfirst = True
 
     activities.index = activities["Activity ID"]
-    work_tracker = WorkTracker("import-strava-checkout-activities")
+    work_tracker = WorkTracker(work_tracker_path("import-strava-checkout-activities"))
     activities_ids_to_parse = work_tracker.filter(activities["Activity ID"])
     activities_ids_to_parse = [
         activity_id
         for activity_id in activities_ids_to_parse
-        if not repository.has_activity(activity_id)
+        if not (activity_extracted_meta_dir() / f"{activity_id.pickle}").exists()
     ]
 
-    activity_stream_dir = pathlib.Path("Cache/Activity Timeseries")
-    activity_stream_dir.mkdir(exist_ok=True, parents=True)
-
     for activity_id in tqdm(activities_ids_to_parse, desc="Import from Strava export"):
+        work_tracker.mark_done(activity_id)
         row = activities.loc[activity_id]
+        # Some manually recorded activities have no file name. Pandas reads that as a float. We skip those.
+        if isinstance(row["Filename"], float):
+            continue
         activity_file = checkout_path / row["Filename"]
         table_activity_meta = {
             "calories": float_or_none(row["Calories"]),
@@ -179,8 +190,11 @@ def import_from_strava_checkout(repository: ActivityRepository) -> None:
                 dateutil.parser.parse(row["Activity Date"], dayfirst=dayfirst)
             ),
         }
+        meta_path = activity_extracted_meta_dir / f"{activity_id}.pickle"
+        with open(meta_path, "wb") as f:
+            pickle.dump(table_activity_meta, meta_path)
 
-        time_series_path = activity_stream_dir / f"{activity_id}.parquet"
+        time_series_path = activity_extracted_time_series_dir / f"{activity_id}.parquet"
         if time_series_path.exists():
             time_series = pd.read_parquet(time_series_path)
         else:
@@ -196,8 +210,6 @@ def import_from_strava_checkout(repository: ActivityRepository) -> None:
                 )
                 raise
 
-        work_tracker.mark_done(activity_id)
-
         if not len(time_series):
             continue
 
@@ -205,10 +217,6 @@ def import_from_strava_checkout(repository: ActivityRepository) -> None:
             continue
 
         time_series.to_parquet(time_series_path)
-
-        repository.add_activity(table_activity_meta)
-
-    repository.commit()
     work_tracker.close()
 
 

geo_activity_playground/webui/activity/controller.py

@@ -452,9 +452,9 @@ def make_sharepic(activity: ActivityMeta, time_series: pd.DataFrame) -> bytes:
         f"\n{activity['distance_km']:.1f} km",
         re.sub(r"^0 days ", "", f"{activity['elapsed_time']}"),
     ]
-    if activity["calories"] and not pd.isna(activity["calories"]):
+    if activity.get("calories", 0) and not pd.isna(activity["calories"]):
         facts.append(f"{activity['calories']:.0f} kcal")
-    if activity["steps"] and not pd.isna(activity["steps"]):
+    if activity.get("steps", 0) and not pd.isna(activity["steps"]):
         facts.append(f"{activity['steps']:.0f} steps")
 
     draw.text((35, img.height - 70 + 10), "      ".join(facts), font_size=20)

geo_activity_playground/webui/activity/templates/activity/show.html.j2

@@ -20,6 +20,8 @@
             <dd>{{ activity.distance_km|round(1) }} km</dd>
             <dt>Elapsed time</dt>
             <dd>{{ activity.elapsed_time }}</dd>
+            <dt>Moving time</dt>
+            <dd>{{ activity.moving_time }}</dd>
             <dt>Start time</dt>
             <dd><a href="{{ url_for('activity.day', year=date.year, month=date.month, day=date.day) }}">{{ date }}</a>
                 {{ time }}