geo-activity-playground 0.20.0__py3-none-any.whl → 0.21.0__py3-none-any.whl

geo_activity_playground/__main__.py

@@ -6,7 +6,6 @@ import sys
 
 import coloredlogs
 
-from .core.similarity import precompute_activity_distances
 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
@@ -105,17 +104,31 @@ def make_activity_repository(
     apply_cache_migrations()
     config = get_config()
 
+    if not config.get("prefer_metadata_from_file", True):
+        logger.error(
+            "The config option `prefer_metadata_from_file` is deprecated. If you want to prefer extract metadata from the activity file paths, please use the new `metadata_extraction_regexes` as explained at https://martin-ueding.github.io/geo-activity-playground/getting-started/using-activity-files/#directory-structure."
+        )
+        sys.exit(1)
+
     repository = ActivityRepository()
 
     if pathlib.Path("Activities").exists():
-        import_from_directory(repository, config.get("prefer_metadata_from_file", True))
+        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)
+
     embellish_time_series(repository)
-    precompute_activity_distances(repository)
     compute_tile_visits(repository)
     compute_tile_evolution()
     return repository

geo_activity_playground/core/activities.py

@@ -37,6 +37,7 @@ class ActivityMeta(TypedDict):
     start_latitude: float
     start_longitude: float
     start: datetime.datetime
+    steps: int
 
 
 class ActivityRepository:
@@ -163,9 +164,6 @@ def embellish_single_time_series(
     timeseries: pd.DataFrame, start: Optional[datetime.datetime] = None
 ) -> bool:
     changed = False
-    time_diff_threshold_seconds = 30
-    time_diff = (timeseries["time"] - timeseries["time"].shift(1)).dt.total_seconds()
-    jump_indices = time_diff >= time_diff_threshold_seconds
 
     if start is not None and pd.api.types.is_dtype_equal(
         timeseries["time"].dtype, "int64"
@@ -176,31 +174,37 @@ def embellish_single_time_series(
         changed = True
     assert pd.api.types.is_dtype_equal(timeseries["time"].dtype, "datetime64[ns, UTC]")
 
-    # Add distance column if missing.
-    if "distance_km" not in timeseries.columns:
-        distances = get_distance(
-            timeseries["latitude"].shift(1),
-            timeseries["longitude"].shift(1),
-            timeseries["latitude"],
-            timeseries["longitude"],
-        ).fillna(0.0)
-        distances.loc[jump_indices] = 0.0
+    distances = get_distance(
+        timeseries["latitude"].shift(1),
+        timeseries["longitude"].shift(1),
+        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 > 100)
+    distances.loc[jump_indices] = 0.0
+
+    if not "distance_km" in timeseries.columns:
         timeseries["distance_km"] = pd.Series(np.cumsum(distances)) / 1000
         changed = True
 
-    if "distance_km" in timeseries.columns:
-        if "speed" not in timeseries.columns:
-            timeseries["speed"] = (
-                timeseries["distance_km"].diff()
-                / (timeseries["time"].diff().dt.total_seconds() + 1e-3)
-                * 3600
-            )
-            changed = True
+    if "speed" not in timeseries.columns:
+        timeseries["speed"] = (
+            timeseries["distance_km"].diff()
+            / (timeseries["time"].diff().dt.total_seconds() + 1e-3)
+            * 3600
+        )
+        changed = True
 
-        potential_jumps = (timeseries["speed"] > 40) & (timeseries["speed"].diff() > 10)
-        if np.any(potential_jumps):
-            timeseries = timeseries.loc[~potential_jumps]
-            changed = True
+    potential_jumps = (timeseries["speed"] > 40) & (timeseries["speed"].diff() > 10)
+    if np.any(potential_jumps):
+        timeseries = timeseries.loc[~potential_jumps].copy()
+        changed = True
+
+    if "segment_id" not in timeseries.columns:
+        timeseries["segment_id"] = np.cumsum(jump_indices)
+        changed = True
 
     if "x" not in timeseries.columns:
         x, y = compute_tile_float(timeseries["latitude"], timeseries["longitude"], 0)
@@ -208,10 +212,6 @@ def embellish_single_time_series(
         timeseries["y"] = y
         changed = True
 
-    if "segment_id" not in timeseries.columns:
-        timeseries["segment_id"] = np.cumsum(jump_indices)
-        changed = True
-
     return timeseries, changed
 
 
@@ -228,6 +228,11 @@ def make_geojson_from_time_series(time_series: pd.DataFrame) -> str:
 
 
 def make_geojson_color_line(time_series: pd.DataFrame) -> str:
+    speed_without_na = time_series["speed"].dropna()
+    low = min(speed_without_na)
+    high = max(speed_without_na)
+    clamp_speed = lambda speed: min(max((speed - low) / (high - low), 0.0), 1.0)
+
     cmap = matplotlib.colormaps["viridis"]
     features = [
         geojson.Feature(
@@ -239,7 +244,7 @@ def make_geojson_color_line(time_series: pd.DataFrame) -> str:
             ),
             properties={
                 "speed": next["speed"] if np.isfinite(next["speed"]) else 0.0,
-                "color": matplotlib.colors.to_hex(cmap(min(next["speed"] / 35, 1.0))),
+                "color": matplotlib.colors.to_hex(cmap(clamp_speed(next["speed"]))),
             },
         )
         for _, group in time_series.groupby("segment_id")
@@ -249,6 +254,19 @@ 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]:
+    speed_without_na = time_series["speed"].dropna()
+    low = min(speed_without_na)
+    high = max(speed_without_na)
+    cmap = matplotlib.colormaps["viridis"]
+    clamp_speed = lambda speed: min(max((speed - low) / (high - low), 0.0), 1.0)
+    colors = [
+        (f"{speed:.1f}", matplotlib.colors.to_hex(cmap(clamp_speed(speed))))
+        for speed in np.linspace(low, high, 10)
+    ]
+    return {"low": low, "high": high, "colors": colors}
+
+
 def extract_heart_rate_zones(time_series: pd.DataFrame) -> Optional[pd.DataFrame]:
     if "heartrate" not in time_series:
         return None

geo_activity_playground/core/activity_parsers.py

@@ -168,6 +168,10 @@ def read_fit_activity(path: pathlib.Path, open) -> tuple[ActivityMeta, pd.DataFr
                         metadata["kind"] = str(values["sport"])
                         if "sub_sport" in values:
                             metadata["kind"] += " " + str(values["sub_sport"])
+                    if "total_calories" in fields:
+                        metadata["calories"] = values["total_calories"]
+                    if "total_strides" in fields:
+                        metadata["steps"] = 2 * int(values["total_strides"])
 
     return metadata, pd.DataFrame(rows)
 

geo_activity_playground/importers/directory.py

@@ -1,9 +1,12 @@
 import hashlib
 import logging
+import multiprocessing
 import pathlib
 import pickle
+import re
 import sys
 import traceback
+from typing import Optional
 
 import pandas as pd
 from tqdm import tqdm
@@ -16,16 +19,18 @@ from geo_activity_playground.core.tasks import WorkTracker
 
 logger = logging.getLogger(__name__)
 
+ACTIVITY_DIR = pathlib.Path("Activities")
+
 
 def import_from_directory(
-    repository: ActivityRepository, prefer_metadata_from_file: bool
+    repository: ActivityRepository, metadata_extraction_regexes: list[str] = []
 ) -> None:
     paths_with_errors = []
     work_tracker = WorkTracker("parse-activity-files")
 
     activity_paths = [
         path
-        for path in pathlib.Path("Activities").rglob("*.*")
+        for path in ACTIVITY_DIR.rglob("*.*")
         if path.is_file() and path.suffixes and not path.stem.startswith(".")
     ]
     new_activity_paths = work_tracker.filter(activity_paths)
@@ -35,36 +40,26 @@ def import_from_directory(
     file_metadata_dir = pathlib.Path("Cache/Activity Metadata")
     file_metadata_dir.mkdir(exist_ok=True, parents=True)
 
-    for path in tqdm(new_activity_paths, desc="Parse activity files"):
+    with multiprocessing.Pool() as pool:
+        paths_with_errors = tqdm(
+            pool.imap(_cache_single_file, new_activity_paths),
+            desc="Parse activity metadata",
+            total=len(new_activity_paths),
+        )
+        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)
-        timeseries_path = activity_stream_dir / f"{activity_id}.parquet"
         file_metadata_path = file_metadata_dir / f"{activity_id}.pickle"
-        work_tracker.mark_done(path)
-
-        if not timeseries_path.exists():
-            try:
-                activity_meta_from_file, timeseries = read_activity(path)
-            except ActivityParseError as e:
-                logger.error(f"Error while parsing file {path}:")
-                traceback.print_exc()
-                paths_with_errors.append((path, str(e)))
-                continue
-            except:
-                logger.error(f"Encountered a problem with {path=}, see details below.")
-                raise
-
-            if len(timeseries) == 0:
-                continue
-
-            timeseries.to_parquet(timeseries_path)
-            with open(file_metadata_path, "wb") as f:
-                pickle.dump(activity_meta_from_file, f)
-        else:
-            with open(file_metadata_path, "rb") as f:
-                activity_meta_from_file = pickle.load(f)
+        work_tracker.mark_done(activity_id)
+
+        if not file_metadata_path.exists():
+            continue
+
+        with open(file_metadata_path, "rb") as f:
+            activity_meta_from_file = pickle.load(f)
 
         activity_meta = ActivityMeta(
-            commute=path.parts[-2] == "Commute",
             id=activity_id,
             # https://stackoverflow.com/a/74718395/653152
             name=path.name.removesuffix("".join(path.suffixes)),
@@ -72,15 +67,8 @@ def import_from_directory(
             kind="Unknown",
             equipment="Unknown",
         )
-        if len(path.parts) >= 3 and path.parts[1] != "Commute":
-            activity_meta["kind"] = path.parts[1]
-        if len(path.parts) >= 4 and path.parts[2] != "Commute":
-            activity_meta["equipment"] = path.parts[2]
-
-        if prefer_metadata_from_file:
-            activity_meta = {**activity_meta, **activity_meta_from_file}
-        else:
-            activity_meta = {**activity_meta_from_file, **activity_meta}
+        activity_meta.update(activity_meta_from_file)
+        activity_meta.update(_get_metadata_from_path(path, metadata_extraction_regexes))
         repository.add_activity(activity_meta)
 
     if paths_with_errors:
@@ -95,9 +83,45 @@ def import_from_directory(
     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"
+
+    if not timeseries_path.exists():
+        try:
+            activity_meta_from_file, timeseries = read_activity(path)
+        except ActivityParseError as e:
+            logger.error(f"Error while parsing file {path}:")
+            traceback.print_exc()
+            return (path, str(e))
+        except:
+            logger.error(f"Encountered a problem with {path=}, see details below.")
+            raise
+
+        if len(timeseries) == 0:
+            return
+
+        timeseries.to_parquet(timeseries_path)
+        with open(file_metadata_path, "wb") as f:
+            pickle.dump(activity_meta_from_file, f)
+
+
 def _get_file_hash(path: pathlib.Path) -> int:
     file_hash = hashlib.blake2s()
     with open(path, "rb") as f:
         while chunk := f.read(8192):
             file_hash.update(chunk)
     return int(file_hash.hexdigest(), 16) % 2**62
+
+
+def _get_metadata_from_path(
+    path: pathlib.Path, metadata_extraction_regexes: list[str]
+) -> dict[str, str]:
+    for regex in metadata_extraction_regexes:
+        if m := re.search(regex, str(path.relative_to(ACTIVITY_DIR))):
+            return m.groupdict()
+    return {}

geo_activity_playground/importers/strava_checkout.py

@@ -3,6 +3,8 @@ import logging
 import pathlib
 import shutil
 import traceback
+from typing import Optional
+from typing import Union
 
 import dateutil.parser
 import numpy as np
@@ -116,6 +118,13 @@ EXPECTED_COLUMNS = [
 ]
 
 
+def float_or_none(x: Union[float, str]) -> Optional[float]:
+    try:
+        return float(x)
+    except ValueError:
+        return None
+
+
 def import_from_strava_checkout(repository: ActivityRepository) -> None:
     checkout_path = pathlib.Path("Strava Export")
     activities = pd.read_csv(checkout_path / "activities.csv")
@@ -143,7 +152,7 @@ def import_from_strava_checkout(repository: ActivityRepository) -> None:
         row = activities.loc[activity_id]
         activity_file = checkout_path / row["Filename"]
         table_activity_meta = {
-            "calories": row["Calories"],
+            "calories": float_or_none(row["Calories"]),
             "commute": row["Commute"] == "true",
             "distance_km": row["Distance"],
             "elapsed_time": datetime.timedelta(seconds=int(row["Elapsed Time"])),

geo_activity_playground/importers/test_directory.py

@@ -0,0 +1,22 @@
+import pathlib
+
+from geo_activity_playground.importers.directory import _get_metadata_from_path
+
+
+def test_get_metadata_from_path() -> None:
+    expected = {
+        "kind": "Radfahrt",
+        "equipment": "Bike 2019",
+        "name": "Foo-Bar to Baz24",
+    }
+    actual = _get_metadata_from_path(
+        pathlib.Path(
+            "Activities/Radfahrt/Bike 2019/Foo-Bar to Baz24/2024-03-03-17-42-10 Something something.fit"
+        ),
+        [
+            r"(?P<kind>[^/]+)/(?P<equipment>[^/]+)/(?P<name>[^/]+)/",
+            r"(?P<kind>[^/]+)/(?P<equipment>[^/]+)/[-\d_ ]+(?P<name>[^/\.]+)(?:\.\w+)+$",
+            r"(?P<kind>[^/]+)/[-\d_ ]+(?P<name>[^/\.]+)(?:\.\w+)+$",
+        ],
+    )
+    assert actual == expected

geo_activity_playground/webui/activity_controller.py

@@ -1,8 +1,12 @@
+import datetime
 import functools
 import io
+import logging
 import pickle
 
 import altair as alt
+import geojson
+import matplotlib
 import matplotlib.pyplot as pl
 import numpy as np
 import pandas as pd
@@ -13,15 +17,17 @@ from geo_activity_playground.core.activities import ActivityRepository
 from geo_activity_playground.core.activities import extract_heart_rate_zones
 from geo_activity_playground.core.activities import make_geojson_color_line
 from geo_activity_playground.core.activities import make_geojson_from_time_series
+from geo_activity_playground.core.activities import make_speed_color_bar
 from geo_activity_playground.core.heatmap import add_margin_to_geo_bounds
 from geo_activity_playground.core.heatmap import build_map_from_tiles
 from geo_activity_playground.core.heatmap import crop_image_to_bounds
 from geo_activity_playground.core.heatmap import get_bounds
 from geo_activity_playground.core.heatmap import get_sensible_zoom_level
 from geo_activity_playground.core.heatmap import OSM_TILE_SIZE
-from geo_activity_playground.core.similarity import distances_path
 from geo_activity_playground.core.tiles import compute_tile_float
 
+logger = logging.getLogger(__name__)
+
 
 class ActivityController:
     def __init__(self, repository: ActivityRepository) -> None:
@@ -34,16 +40,12 @@ class ActivityController:
         time_series = self._repository.get_time_series(id)
         line_json = make_geojson_from_time_series(time_series)
 
-        with open(distances_path, "rb") as f:
-            distances = pickle.load(f)
-
-        similar_activites = {
-            distance: [
-                self._repository.get_activity_by_id(activity_id)
-                for activity_id in distances[activity.id].get(distance, set())
-            ]
-            for distance in range(10)
-        }
+        meta = self._repository.meta
+        similar_activities = meta.loc[
+            (meta.name == activity["name"]) & (meta.id != activity["id"])
+        ]
+        similar_activities = [row for _, row in similar_activities.iterrows()]
+        similar_activities.reverse()
 
         result = {
             "activity": activity,
@@ -52,7 +54,10 @@ class ActivityController:
             "color_line_geojson": make_geojson_color_line(time_series),
             "speed_time_plot": speed_time_plot(time_series),
             "speed_distribution_plot": speed_distribution_plot(time_series),
-            "similar_activites": similar_activites,
+            "similar_activites": similar_activities,
+            "speed_color_bar": make_speed_color_bar(time_series),
+            "date": activity.start.date(),
+            "time": activity.start.time(),
         }
         if (heart_zones := extract_heart_rate_zones(time_series)) is not None:
             result["heart_zones_plot"] = heartrate_zone_plot(heart_zones)
@@ -66,6 +71,124 @@ class ActivityController:
         time_series = self._repository.get_time_series(id)
         return make_sharepic(time_series)
 
+    def render_day(self, year: int, month: int, day: int) -> dict:
+        meta = self._repository.meta
+        selection = meta["start"].dt.date == datetime.date(year, month, day)
+        activities_that_day = meta.loc[selection]
+
+        time_series = [
+            self._repository.get_time_series(activity_id)
+            for activity_id in activities_that_day["id"]
+        ]
+
+        cmap = matplotlib.colormaps["Dark2"]
+        fc = geojson.FeatureCollection(
+            features=[
+                geojson.Feature(
+                    geometry=geojson.MultiLineString(
+                        coordinates=[
+                            [
+                                [lon, lat]
+                                for lat, lon in zip(
+                                    group["latitude"], group["longitude"]
+                                )
+                            ]
+                            for _, group in ts.groupby("segment_id")
+                        ]
+                    ),
+                    properties={"color": matplotlib.colors.to_hex(cmap(i % 8))},
+                )
+                for i, ts in enumerate(time_series)
+            ]
+        )
+
+        activities_list = activities_that_day.to_dict(orient="records")
+        for i, activity_record in enumerate(activities_list):
+            activity_record["color"] = matplotlib.colors.to_hex(cmap(i % 8))
+
+        return {
+            "activities": activities_list,
+            "geojson": geojson.dumps(fc),
+            "date": datetime.date(year, month, day).isoformat(),
+        }
+
+    def render_all(self) -> dict:
+        cmap = matplotlib.colormaps["Dark2"]
+        fc = geojson.FeatureCollection(
+            features=[
+                geojson.Feature(
+                    geometry=geojson.MultiLineString(
+                        coordinates=[
+                            [
+                                [lon, lat]
+                                for lat, lon in zip(
+                                    group["latitude"], group["longitude"]
+                                )
+                            ]
+                            for _, group in self._repository.get_time_series(
+                                activity["id"]
+                            ).groupby("segment_id")
+                        ]
+                    ),
+                    properties={
+                        "color": matplotlib.colors.to_hex(cmap(i % 8)),
+                        "activity_name": activity["name"],
+                        "activity_id": str(activity["id"]),
+                    },
+                )
+                for i, activity in enumerate(self._repository.iter_activities())
+            ]
+        )
+
+        return {
+            "geojson": geojson.dumps(fc),
+        }
+
+    def render_name(self, name: str) -> dict:
+        meta = self._repository.meta
+        selection = meta["name"] == name
+        activities_with_name = meta.loc[selection]
+
+        time_series = [
+            self._repository.get_time_series(activity_id)
+            for activity_id in activities_with_name["id"]
+        ]
+
+        cmap = matplotlib.colormaps["Dark2"]
+        fc = geojson.FeatureCollection(
+            features=[
+                geojson.Feature(
+                    geometry=geojson.MultiLineString(
+                        coordinates=[
+                            [
+                                [lon, lat]
+                                for lat, lon in zip(
+                                    group["latitude"], group["longitude"]
+                                )
+                            ]
+                            for _, group in ts.groupby("segment_id")
+                        ]
+                    ),
+                    properties={"color": matplotlib.colors.to_hex(cmap(i % 8))},
+                )
+                for i, ts in enumerate(time_series)
+            ]
+        )
+
+        activities_list = activities_with_name.to_dict(orient="records")
+        for i, activity_record in enumerate(activities_list):
+            activity_record["color"] = matplotlib.colors.to_hex(cmap(i % 8))
+
+        return {
+            "activities": activities_list,
+            "geojson": geojson.dumps(fc),
+            "name": name,
+            "tick_plot": name_tick_plot(activities_with_name),
+            "equipment_plot": name_equipment_plot(activities_with_name),
+            "distance_plot": name_distance_plot(activities_with_name),
+            "minutes_plot": name_minutes_plot(activities_with_name),
+        }
+
 
 def speed_time_plot(time_series: pd.DataFrame) -> str:
     return (
@@ -154,6 +277,51 @@ def heartrate_zone_plot(heart_zones: pd.DataFrame) -> str:
     )
 
 
+def name_tick_plot(meta: pd.DataFrame) -> str:
+    return (
+        alt.Chart(meta, title="Repetitions")
+        .mark_tick()
+        .encode(
+            alt.X("start", title="Date"),
+        )
+        .to_json(format="vega")
+    )
+
+
+def name_equipment_plot(meta: pd.DataFrame) -> str:
+    return (
+        alt.Chart(meta, title="Equipment")
+        .mark_bar()
+        .encode(alt.X("count()", title="Count"), alt.Y("equipment", title="Equipment"))
+        .to_json(format="vega")
+    )
+
+
+def name_distance_plot(meta: pd.DataFrame) -> str:
+    return (
+        alt.Chart(meta, title="Distance")
+        .mark_bar()
+        .encode(
+            alt.X("distance_km", bin=True, title="Distance / km"),
+            alt.Y("count()", title="Count"),
+        )
+        .to_json(format="vega")
+    )
+
+
+def name_minutes_plot(meta: pd.DataFrame) -> str:
+    minutes = meta["elapsed_time"].dt.total_seconds() / 60
+    return (
+        alt.Chart(pd.DataFrame({"minutes": minutes}), title="Elapsed time")
+        .mark_bar()
+        .encode(
+            alt.X("minutes", bin=True, title="Time / min"),
+            alt.Y("count()", title="Count"),
+        )
+        .to_json(format="vega")
+    )
+
+
 def make_sharepic(time_series: pd.DataFrame) -> bytes:
     lat_lon_data = np.array([time_series["latitude"], time_series["longitude"]]).T
 

geo_activity_playground/webui/app.py

@@ -1,3 +1,5 @@
+import urllib
+
 from flask import Flask
 from flask import redirect
 from flask import render_template
@@ -29,6 +31,12 @@ from geo_activity_playground.webui.tile_controller import (
 def route_activity(app: Flask, repository: ActivityRepository) -> None:
     activity_controller = ActivityController(repository)
 
+    @app.route("/activity/all")
+    def activity_all():
+        return render_template(
+            "activity-lines.html.j2", **activity_controller.render_all()
+        )
+
     @app.route("/activity/<id>")
     def activity(id: str):
         return render_template(
@@ -42,6 +50,20 @@ def route_activity(app: Flask, repository: ActivityRepository) -> None:
             mimetype="image/png",
         )
 
+    @app.route("/activity/day/<year>/<month>/<day>")
+    def activity_day(year: str, month: str, day: str):
+        return render_template(
+            "activity-day.html.j2",
+            **activity_controller.render_day(int(year), int(month), int(day))
+        )
+
+    @app.route("/activity/name/<name>")
+    def activity_name(name: str):
+        return render_template(
+            "activity-name.html.j2",
+            **activity_controller.render_name(urllib.parse.unquote(name))
+        )
+
 
 def route_calendar(app: Flask, repository: ActivityRepository) -> None:
     calendar_controller = CalendarController(repository)
@@ -53,7 +75,7 @@ def route_calendar(app: Flask, repository: ActivityRepository) -> None:
         )
 
     @app.route("/calendar/<year>/<month>")
-    def calendar_year_month(year: str, month: str):
+    def calendar_month(year: str, month: str):
         return render_template(
             "calendar-month.html.j2",
             **calendar_controller.render_month(int(year), int(month))
@@ -264,8 +286,7 @@ def route_tiles(app: Flask, repository: ActivityRepository) -> None:
     @app.route("/tile/color/<z>/<x>/<y>.png")
     def tile_color(x: str, y: str, z: str):
         return Response(
-            tile_controller.render_color(int(x), int(y), int(z)),
-            mimetype="image/png",
+            tile_controller.render_color(int(x), int(y), int(z)), mimetype="image/png"
         )
 
     @app.route("/tile/grayscale/<z>/<x>/<y>.png")
@@ -275,6 +296,12 @@ def route_tiles(app: Flask, repository: ActivityRepository) -> None:
             mimetype="image/png",
         )
 
+    @app.route("/tile/pastel/<z>/<x>/<y>.png")
+    def tile_pastel(x: str, y: str, z: str):
+        return Response(
+            tile_controller.render_pastel(int(x), int(y), int(z)), mimetype="image/png"
+        )
+
 
 def webui_main(repository: ActivityRepository, host: str, port: int) -> None:
     app = Flask(__name__)

geo_activity_playground/webui/calendar_controller.py

@@ -2,8 +2,6 @@ import collections
 import datetime
 import functools
 
-import pandas as pd
-
 from geo_activity_playground.core.activities import ActivityRepository
 
 
@@ -58,11 +56,12 @@ class CalendarController:
         ].sort_values("start")
 
         weeks = collections.defaultdict(dict)
-
+        day_of_month = collections.defaultdict(dict)
         date = datetime.datetime(year, month, 1)
         while date.month == month:
             iso = date.isocalendar()
             weeks[iso.week][iso.weekday] = []
+            day_of_month[iso.week][iso.weekday] = date.day
             date += datetime.timedelta(days=1)
 
         for index, row in filtered.iterrows():
@@ -76,4 +75,9 @@ class CalendarController:
                 }
             )
 
-        return {"year": year, "month": month, "weeks": weeks}
+        return {
+            "year": year,
+            "month": month,
+            "weeks": weeks,
+            "day_of_month": day_of_month,
+        }

geo_activity_playground/webui/templates/activity-day.html.j2

@@ -0,0 +1,71 @@
+{% extends "page.html.j2" %}
+
+{% block container %}
+<div class="row mb-3">
+    <div class="col">
+        <h1>{{ date }}</h1>
+    </div>
+</div>
+
+
+<div class="row mb-3">
+    <div class="col-md-9">
+        <div id="activity-map" style="height: 500px;"></div>
+        <script>
+            var map = L.map('activity-map', {
+                fullscreenControl: true
+            });
+            L.tileLayer('/tile/grayscale/{z}/{x}/{y}.png', {
+                maxZoom: 19,
+                attribution: '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a>'
+            }).addTo(map);
+
+            let geojson = L.geoJSON({{ geojson| safe }}, {
+                style: function (feature) { return { color: feature.properties.color } }
+            }).addTo(map)
+            map.fitBounds(geojson.getBounds());
+        </script>
+    </div>
+    <div class="col-md-3">
+        <ol>
+            {% for activity in activities %}
+            <li><span style="color: {{ activity['color'] }};">█</span> <a href="/activity/{{ activity.id }}">{{
+                    activity.name }}</a></li>
+            {% endfor %}
+        </ol>
+    </div>
+</div>
+
+<div class="row mb-3">
+    <div class="col">
+        <h2>Activities</h2>
+
+        <table class="table">
+            <thead>
+                <tr>
+                    <th>Name</th>
+                    <th>Date</th>
+                    <th>Distance / km</th>
+                    <th>Elapsed time</th>
+                    <th>Equipment</th>
+                    <th>Kind</th>
+                </tr>
+            </thead>
+            <tbody>
+                {% for activity in activities %}
+                <tr>
+                    <td><span style="color: {{ activity['color'] }};">█</span> <a href="/activity/{{ activity.id }}">{{
+                            activity.name }}</a></td>
+                    <td>{{ activity.start }}</td>
+                    <td>{{ activity.distance_km | round(1) }}</td>
+                    <td>{{ activity.elapsed_time }}</td>
+                    <td>{{ activity["equipment"] }}</td>
+                    <td>{{ activity["kind"] }}</td>
+                </tr>
+                {% endfor %}
+            </tbody>
+        </table>
+    </div>
+</div>
+
+{% endblock %}

geo_activity_playground/webui/templates/activity-lines.html.j2

@@ -0,0 +1,36 @@
+{% extends "page.html.j2" %}
+
+{% block container %}
+
+<div class="row mb-3">
+    <div class="col">
+        <h1>All Activity Lines</h1>
+    </div>
+</div>
+
+<div class="row mb-3">
+    <div class="col-md-12">
+        <div id="activity-map" style="height: 500px;"></div>
+        <script>
+            function onEachFeature(feature, layer) {
+                layer.bindPopup(`<a href=/activity/${feature.properties.activity_id}>${feature.properties.activity_name}</a>`)
+            }
+
+            var map = L.map('activity-map', {
+                fullscreenControl: true
+            });
+            L.tileLayer('/tile/grayscale/{z}/{x}/{y}.png', {
+                maxZoom: 19,
+                attribution: '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a>'
+            }).addTo(map);
+
+            let geojson = L.geoJSON({{ geojson| safe }}, {
+                style: function (feature) { return { color: feature.properties.color } },
+                onEachFeature: onEachFeature
+            }).addTo(map)
+            map.fitBounds(geojson.getBounds());
+        </script>
+    </div>
+</div>
+
+{% endblock %}

geo_activity_playground/webui/templates/activity-name.html.j2

@@ -0,0 +1,81 @@
+{% extends "page.html.j2" %}
+
+{% block container %}
+<div class="row mb-3">
+    <div class="col">
+        <h1>{{ name }}</h1>
+    </div>
+</div>
+
+
+<div class="row mb-3">
+    <div class="col-md-12">
+        <div id="activity-map" style="height: 500px;"></div>
+        <script>
+            var map = L.map('activity-map', {
+                fullscreenControl: true
+            });
+            L.tileLayer('/tile/grayscale/{z}/{x}/{y}.png', {
+                maxZoom: 19,
+                attribution: '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a>'
+            }).addTo(map);
+
+            let geojson = L.geoJSON({{ geojson| safe }}, {
+                style: function (feature) { return { color: feature.properties.color } }
+            }).addTo(map)
+            map.fitBounds(geojson.getBounds());
+        </script>
+    </div>
+</div>
+
+<div class="row mb-3">
+    <div class="col-md-4">
+        {{ vega_direct("tick_plot", tick_plot) }}
+    </div>
+    <div class="col-md-4">
+        {{ vega_direct("equipment_plot", equipment_plot) }}
+    </div>
+</div>
+
+<div class="row mb-3">
+    <div class="col-md-4">
+        {{ vega_direct("distance_plot", distance_plot) }}
+    </div>
+    <div class="col-md-4">
+        {{ vega_direct("minutes_plot", minutes_plot) }}
+    </div>
+</div>
+
+<div class="row mb-3">
+    <div class="col">
+        <h2>Activities</h2>
+
+        <table class="table">
+            <thead>
+                <tr>
+                    <th>Name</th>
+                    <th>Date</th>
+                    <th>Distance / km</th>
+                    <th>Elapsed time</th>
+                    <th>Equipment</th>
+                    <th>Kind</th>
+                </tr>
+            </thead>
+            <tbody>
+                {% for activity in activities %}
+                <tr>
+                    <td><span style="color: {{ activity['color'] }};">█</span> <a href="/activity/{{ activity.id }}">{{
+                            activity.name }}</a></td>
+                    <td>{{ activity.start }}</td>
+                    <td>{{ activity.distance_km | round(1) }}</td>
+                    <td>{{ activity.elapsed_time }}</td>
+                    <td>{{ activity["equipment"] }}</td>
+                    <td>{{ activity["kind"] }}</td>
+                </tr>
+                {% endfor %}
+            </tbody>
+        </table>
+    </div>
+</div>
+
+{% endblock %}

geo_activity_playground/webui/templates/activity.html.j2

@@ -21,9 +21,12 @@
             <dt>Elapsed time</dt>
             <dd>{{ activity.elapsed_time }}</dd>
             <dt>Start time</dt>
-            <dd>{{ activity.start }}</dd>
+            <dd><a href="/activity/day/{{ date.year }}/{{ date.month }}/{{ date.day }}">{{ date }}</a> {{ time }}
+            </dd>
             <dt>Calories</dt>
             <dd>{{ activity.calories }}</dd>
+            <dt>Steps</dt>
+            <dd>{{ activity.steps }}</dd>
             <dt>Equipment</dt>
             <dd>{{ activity.equipment }}</dd>
             <dt>ID</dt>
@@ -33,12 +36,12 @@
         </dl>
     </div>
     <div class="col-8">
-        <div id="activity-map" style="height: 500px;"></div>
+        <div id="activity-map" style="height: 500px;" class="mb-3"></div>
         <script>
             var map = L.map('activity-map', {
                 fullscreenControl: true
             });
-            L.tileLayer('/tile/color/{z}/{x}/{y}.png', {
+            L.tileLayer('/tile/pastel/{z}/{x}/{y}.png', {
                 maxZoom: 19,
                 attribution: '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a>'
             }).addTo(map);
@@ -48,6 +51,24 @@
             }).addTo(map)
             map.fitBounds(geojson.getBounds());
         </script>
+
+
+        <style>
+            span.colorbar {
+                text-shadow: -1px -1px 0 black, -1px 0px 0 black, -1px 1px 0 black, 0px -1px 0 black, 0px 0px 0 black, 0px 1px 0 black, 1px -1px 0 black, 1px 0px 0 black, 1px 1px 0 black;
+                padding-left: 5px;
+                padding-right: 5px;
+                line-height: 130%;
+                color: white;
+            }
+        </style>
+
+        <div>
+            {% for speed, color in speed_color_bar.colors %}
+            <span class="colorbar" style="width: 15px; background-color: {{ color }}">{{ speed }}</span>
+            {% endfor %}
+            km/h
+        </div>
     </div>
 </div>
 
@@ -109,35 +130,38 @@
     </div>
 </div>
 
+{% if similar_activites|length > 0 %}
 <div class="row mb-3">
     <div class="col">
-        <h2>Similar activities</h2>
+        <h2>Activities with the same name</h2>
+
+        <p><a href="/activity/name/{{ activity['name']|urlencode() }}">Overview over these activities</a></p>
 
         <table class="table">
             <thead>
                 <tr>
-                    <th>Hamming distance</th>
-                    <th>Name</th>
                     <th>Date</th>
                     <th>Distance / km</th>
                     <th>Elapsed time</th>
+                    <th>Equipment</th>
+                    <th>Kind</th>
                 </tr>
             </thead>
             <tbody>
-                {% for distance, other_activities in similar_activites.items() %}
-                {% for other_activity in other_activities %}
+                {% for other_activity in similar_activites %}
                 <tr>
-                    <td>{{ distance }}</td>
-                    <td><a href="/activity/{{ other_activity.id }}">{{ other_activity["name"] }}</a></td>
-                    <td>{{ other_activity.start }}</td>
+                    <td><a href="/activity/{{ other_activity.id }}">{{ other_activity.start
+                            }}</a></td>
                     <td>{{ other_activity.distance_km | round(1) }}</td>
                     <td>{{ other_activity.elapsed_time }}</td>
+                    <td>{{ other_activity["equipment"] }}</td>
+                    <td>{{ other_activity["kind"] }}</td>
                 </tr>
                 {% endfor %}
-                {% endfor %}
             </tbody>
         </table>
     </div>
 </div>
+{% endif %}
 
 {% endblock %}

geo_activity_playground/webui/templates/calendar-month.html.j2

@@ -28,6 +28,13 @@
                     <td>{{ week }}</td>
                     {% for day in range(1, 8) %}
                     <td>
+                        {% if weeks[week][day] %}
+                        <a href="/activity/day/{{ year }}/{{ month }}/{{ day_of_month[week][day] }}"><b>{{
+                                day_of_month[week][day] }}.</b></a>
+                        {% elif day_of_month[week][day] %}
+                        <b>{{ day_of_month[week][day] }}.</b>
+                        {% endif %}
+
                         {% if weeks[week][day] %}
                         <ul>
                             {% for activity in weeks[week][day] %}

geo_activity_playground/webui/tile_controller.py

@@ -20,3 +20,13 @@ class TileController:
         f = io.BytesIO()
         pl.imsave(f, map_tile, format="png")
         return bytes(f.getbuffer())
+
+    def render_pastel(self, x: int, y: int, z: int) -> bytes:
+        map_tile = np.array(get_tile(z, x, y)) / 255
+        averaged_tile = np.sum(map_tile * [0.2126, 0.7152, 0.0722], axis=2)
+        grayscale_tile = np.dstack((averaged_tile, averaged_tile, averaged_tile))
+        factor = 0.7
+        pastel_tile = factor * grayscale_tile + (1 - factor) * map_tile
+        f = io.BytesIO()
+        pl.imsave(f, pastel_tile, format="png")
+        return bytes(f.getbuffer())

{geo_activity_playground-0.20.0.dist-info → geo_activity_playground-0.21.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: geo-activity-playground
-Version: 0.20.0
+Version: 0.21.0
 Summary: Analysis of geo data activities like rides, runs or hikes.
 License: MIT
 Author: Martin Ueding
@@ -20,7 +20,6 @@ Requires-Dist: fitdecode (>=0.10.0,<0.11.0)
 Requires-Dist: flask (>=3.0.0,<4.0.0)
 Requires-Dist: geojson (>=3.0.1,<4.0.0)
 Requires-Dist: gpxpy (>=1.5.0,<2.0.0)
-Requires-Dist: imagehash (>=4.3.1,<5.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)

{geo_activity_playground-0.20.0.dist-info → geo_activity_playground-0.21.0.dist-info}/RECORD

@@ -1,8 +1,8 @@
 geo_activity_playground/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-geo_activity_playground/__main__.py,sha256=_HgWroTbozlbWUipBdIrcqMxLB4nd5OdPcDD-8kDlq4,4337
+geo_activity_playground/__main__.py,sha256=z8CaA2SgW7PQ4peK-D5Z6JXz79k3v3GMGQsYS28TjlA,4990
 geo_activity_playground/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-geo_activity_playground/core/activities.py,sha256=-hMSewcvhZ_93Fpr9BhYFrwIfK9ooZChbJ6V8nF1x0A,10380
-geo_activity_playground/core/activity_parsers.py,sha256=2EurI33yTZRF0MaFJa5FsyQLQW4jNsV_I7RViJ4y9zE,11190
+geo_activity_playground/core/activities.py,sha256=-2stf_xJ1C2j-KV08wj5Y-uuuV6w01RN3bh8Gvuti1I,10986
+geo_activity_playground/core/activity_parsers.py,sha256=GYDaKi5lFo5YIThoRc0enmwwgWkTfJKCxiPsSkpHBxw,11440
 geo_activity_playground/core/cache_migrations.py,sha256=cz7zwoYtjAcFbUQee1UqeyHT0K2oiyfpPVh5tXkzk0U,3479
 geo_activity_playground/core/config.py,sha256=YjqCiEmIAa-GM1-JfBctMEsl8-I56pZyyDdTyPduOzw,477
 geo_activity_playground/core/coordinates.py,sha256=tDfr9mlXhK6E_MMIJ0vYWVCoH0Lq8uyuaqUgaa8i0jg,966
@@ -16,13 +16,14 @@ geo_activity_playground/explorer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRk
 geo_activity_playground/explorer/grid_file.py,sha256=0PCFd6WE1uL3PXwZNeseURuFY7ImEVREoZpTObKiU1U,3258
 geo_activity_playground/explorer/tile_visits.py,sha256=z6ExfywFNOQ6dh2NZ9wOR_I3XkAvByIaM8O27WM5hH4,10745
 geo_activity_playground/explorer/video.py,sha256=RGZik93ghfZuRILXf8pfUbPh5VV37_QRAR4FgOMfZqQ,4354
-geo_activity_playground/importers/directory.py,sha256=uKqfkp7UmoyL0AiJv8fIrG2qoMuPcVT25ZsAgqno-9U,3704
+geo_activity_playground/importers/directory.py,sha256=8UVgVr20RBf5_Pp7xJfvE-cSbFWWXVFNEzpcE7MdeEo,4331
 geo_activity_playground/importers/strava_api.py,sha256=yg1SWt_kbyMYFD5uOp7I0uDUtmAOgQvD2Gx3CZZ_ME8,7615
-geo_activity_playground/importers/strava_checkout.py,sha256=TYh_FW7L5jv0oIZYmY8UmaNOf0Y6cHCefyqTpjZub7c,7037
+geo_activity_playground/importers/strava_checkout.py,sha256=0lR4aV1yGjIOcmkt4Govrei-mRttbajfXl-yKEgSdLs,7243
+geo_activity_playground/importers/test_directory.py,sha256=ljXokx7q0OgtHvEdHftcQYEmZJUDVv3OOF5opklxdT4,724
 geo_activity_playground/importers/test_strava_api.py,sha256=4vX7wDr1a9aRh8myxNrIq6RwDBbP8ZeoXXPc10CAbW4,431
-geo_activity_playground/webui/activity_controller.py,sha256=5N4LqRtiVDvDBfD_UQRicGZLB3QPkUiahcKcl0nZxzY,6631
-geo_activity_playground/webui/app.py,sha256=mfbgyrWpAY0CFgKCi69a8x3pFvQ7BKWXpGhzAC4S2LI,10211
-geo_activity_playground/webui/calendar_controller.py,sha256=1y2a8StGyrO2JNfQvktu8ylGhvju-VQesitzftZHihU,2634
+geo_activity_playground/webui/activity_controller.py,sha256=yM7-EPcoKen-e9mt4D7UWo-E7Zk7Y39_-kr2IV7Km6U,12515
+geo_activity_playground/webui/app.py,sha256=759gC8M1vw2zjH4Zt4Pk9KqWd5RVjl6htu7f76vFrS4,11089
+geo_activity_playground/webui/calendar_controller.py,sha256=vn9YNQglbBrQd3IVIU6d2vT3BxGaW0kcRsXLOjuZgqI,2813
 geo_activity_playground/webui/config_controller.py,sha256=4M8mQc58Hkm-ssfYF1gKRepiAXFIzkZdIMRSbX-aI1U,320
 geo_activity_playground/webui/eddington_controller.py,sha256=06YLPeXTrCMgI4eNwbhmXQEyVAK-yAk0OT5XGzjHY-Q,2646
 geo_activity_playground/webui/entry_controller.py,sha256=4rgMvM_1N1p1IxkDIIf20XQnbsNK3h2jdnXgUg58VOU,1904
@@ -45,8 +46,11 @@ geo_activity_playground/webui/static/safari-pinned-tab.svg,sha256=OzoEVGY0igWRXM
 geo_activity_playground/webui/static/site.webmanifest,sha256=4vYxdPMpwTdB8EmOvHkkYcjZ8Yrci3pOwwY3o_VwACA,440
 geo_activity_playground/webui/strava_controller.py,sha256=-DZ1Ae-0cWx5tia2dJpGfsBBoIya0QO7IC2qa1-7Q_U,779
 geo_activity_playground/webui/summary_controller.py,sha256=CN64yUQkhGFC11iiG8_83E3rYFdRixB5Dl_mUhqSo28,1806
-geo_activity_playground/webui/templates/activity.html.j2,sha256=9S6bTsLiIuf7ZXHp8Vz4AEDTcKE4ZjpNX0arxb7Ycsc,4032
-geo_activity_playground/webui/templates/calendar-month.html.j2,sha256=LVokl95lPlYpUo-5FbDe3n3SES3LE-MABg0BOcdqP7s,1384
+geo_activity_playground/webui/templates/activity-day.html.j2,sha256=LiYe5e_b8t7k0ZS6Lk8E0bpm-I4-kc-SRS-P8UUQBYI,2237
+geo_activity_playground/webui/templates/activity-lines.html.j2,sha256=5gB1aDjRgi_RventenRfC10_FtMT4ch_VuWvA9AMlBY,1121
+geo_activity_playground/webui/templates/activity-name.html.j2,sha256=opHCj_zY3Xz1l3jIXUQvVdxBNi_D9C-Mdnbx2nQqTTQ,2381
+geo_activity_playground/webui/templates/activity.html.j2,sha256=ncj0K1471nRHtbBL9fqhGZ7a9DoJLyqt6ckX8rnhS28,4946
+geo_activity_playground/webui/templates/calendar-month.html.j2,sha256=rV96gOXS0eZU3Dokg8Wb7AJVXJvTPsw61OJoj8lRvt4,1767
 geo_activity_playground/webui/templates/calendar.html.j2,sha256=x3E1R6KoscVxfcndFePEA855tYz5UoHDSrDbjkhuOOs,1349
 geo_activity_playground/webui/templates/config.html.j2,sha256=pmec-TqSl5CVznQlyHuC91o18qa0ZQWHXxSBrlV4au4,796
 geo_activity_playground/webui/templates/eddington.html.j2,sha256=yl75IzWeIkFpwPj8FjTrzJsz_f-qdETPmNnAGLPJuL8,487
@@ -60,9 +64,9 @@ geo_activity_playground/webui/templates/search.html.j2,sha256=lYFe9PzP8gqTenhZuf
 geo_activity_playground/webui/templates/square-planner.html.j2,sha256=aIB0ql5qW4HXfp0ENksYYOk9vTgBitwyHJX5W7bqkeY,6512
 geo_activity_playground/webui/templates/strava-connect.html.j2,sha256=vLMqTnTV-DZJ1FHRjpm4OMgbABMwZQvbs8Ru9baKeBg,1111
 geo_activity_playground/webui/templates/summary.html.j2,sha256=eEwcPOURJ-uT89jeJGZHq_5pSq56_fTC7z-j_m5nQiA,471
-geo_activity_playground/webui/tile_controller.py,sha256=kkZvZ4wUdp-HLoHDmhX1IVdCYKsQR_vg9i5mMI9N0R4,745
-geo_activity_playground-0.20.0.dist-info/LICENSE,sha256=4RpAwKO8bPkfXH2lnpeUW0eLkNWglyG4lbrLDU_MOwY,1070
-geo_activity_playground-0.20.0.dist-info/METADATA,sha256=ymLK0qHTxydFVtgWUQ8oY_FMHdTtO--nQTur7JDd95Q,1615
-geo_activity_playground-0.20.0.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
-geo_activity_playground-0.20.0.dist-info/entry_points.txt,sha256=pbNlLI6IIZIp7nPYCfAtiSiz2oxJSCl7DODD6SPkLKk,81
-geo_activity_playground-0.20.0.dist-info/RECORD,,
+geo_activity_playground/webui/tile_controller.py,sha256=PISh4vKs27b-LxFfTARtr5RAwHFresA1Kw1MDcERSRU,1221
+geo_activity_playground-0.21.0.dist-info/LICENSE,sha256=4RpAwKO8bPkfXH2lnpeUW0eLkNWglyG4lbrLDU_MOwY,1070
+geo_activity_playground-0.21.0.dist-info/METADATA,sha256=lbVR-EIvkZ05oPkGHW3WgXI1Wn8io-ale9X9de6up0s,1573
+geo_activity_playground-0.21.0.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+geo_activity_playground-0.21.0.dist-info/entry_points.txt,sha256=pbNlLI6IIZIp7nPYCfAtiSiz2oxJSCl7DODD6SPkLKk,81
+geo_activity_playground-0.21.0.dist-info/RECORD,,

{geo_activity_playground-0.20.0.dist-info → geo_activity_playground-0.21.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.6.1
+Generator: poetry-core 1.8.1
 Root-Is-Purelib: true
 Tag: py3-none-any