geo-activity-playground 0.6.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

geo_activity_playground/__main__.py

@@ -1,16 +1,11 @@
 import argparse
 import os
 import pathlib
-import tomllib
 
 import coloredlogs
 
 from geo_activity_playground.core.activities import ActivityRepository
-from geo_activity_playground.core.sources import TimeSeriesSource
-from geo_activity_playground.explorer.grid_file import get_border_tiles
-from geo_activity_playground.explorer.grid_file import get_explored_tiles
-from geo_activity_playground.explorer.grid_file import make_grid_file_geojson
-from geo_activity_playground.explorer.grid_file import make_grid_file_gpx
+from geo_activity_playground.core.config import get_config
 from geo_activity_playground.explorer.video import explorer_video_main
 from geo_activity_playground.heatmap import generate_heatmaps_per_cluster
 from geo_activity_playground.importers.directory import import_from_directory
@@ -78,11 +73,10 @@ def main() -> None:
 
 def make_activity_repository(basedir: pathlib.Path) -> ActivityRepository:
     os.chdir(basedir)
+    config = get_config()
     if pathlib.Path("Activities").exists():
         import_from_directory()
-    elif pathlib.Path("config.toml").exists():
-        with open("config.toml", "rb") as f:
-            config = tomllib.load(f)
+    elif config:
         if "strava" in config:
             import_from_strava_api()
     return ActivityRepository()

geo_activity_playground/core/activities.py

@@ -2,16 +2,15 @@ import dataclasses
 import datetime
 import functools
 import logging
-import pathlib
-import tomllib
 from typing import Iterator
 from typing import Optional
 
 import geojson
 import matplotlib
-import numpy as np
 import pandas as pd
 
+from geo_activity_playground.core.config import get_config
+
 
 logger = logging.getLogger(__name__)
 
@@ -105,25 +104,35 @@ def make_geojson_color_line(time_series: pd.DataFrame) -> str:
 def extract_heart_rate_zones(time_series: pd.DataFrame) -> Optional[pd.DataFrame]:
     if "heartrate" not in time_series:
         return None
-    config_path = pathlib.Path("config.toml")
-    if not config_path.exists():
-        logger.warning("Missing a config, cannot extract heart rate zones.")
-        return None
-    with open(config_path, "rb") as f:
-        config = tomllib.load(f)
-
+    config = get_config()
     try:
-        birthyear = config["heart"]["birthyear"]
+        heart_config = config["heart"]
     except KeyError:
         logger.warning(
-            "Missing config entry `heart.birthyear`, cannot determine heart rate zones."
+            "Missing config entry `heart`, cannot determine heart rate zones."
+        )
+        return None
+
+    birthyear = heart_config.get("birthyear", None)
+    maximum = heart_config.get("maximum", None)
+    resting = heart_config.get("resting", None)
+
+    if not maximum and birthyear:
+        age = time_series["time"].iloc[0].year - birthyear
+        maximum = 220 - age
+    if not resting:
+        resting = 0
+    if not maximum:
+        logger.warning(
+            "Missing config entry `heart.maximum` or `heart.birthyear`, cannot determine heart rate zones."
         )
         return None
 
-    age = time_series["time"].iloc[0].year - birthyear
-    max_rate = 220 - age
-    zones: pd.Series = time_series["heartrate"] * 10 // max_rate - 4
+    zones: pd.Series = (time_series["heartrate"] - resting) * 10 // (
+        maximum - resting
+    ) - 4
     zones.loc[zones < 0] = 0
+    zones.loc[zones > 5] = 5
     df = pd.DataFrame({"heartzone": zones, "step": time_series["time"].diff()}).dropna()
     duration_per_zone = df.groupby("heartzone").sum()["step"].dt.total_seconds() / 60
     duration_per_zone.name = "minutes"

geo_activity_playground/core/config.py

@@ -0,0 +1,22 @@
+import functools
+import logging
+import pathlib
+
+
+try:
+    import tomllib
+except ModuleNotFoundError:
+    import tomli as tomllib
+
+
+logger = logging.getLogger(__name__)
+
+
+@functools.cache
+def get_config() -> dict:
+    config_path = pathlib.Path("config.toml")
+    if not config_path.exists():
+        logger.warning("Missing a config, some features might be missing.")
+        return {}
+    with open(config_path, "rb") as f:
+        return tomllib.load(f)

geo_activity_playground/core/tiles.py

@@ -11,7 +11,7 @@ from PIL import Image
 logger = logging.getLogger(__name__)
 
 
-def compute_tile(lat: float, lon: float, zoom: int = 14) -> tuple[int, int]:
+def compute_tile(lat: float, lon: float, zoom: int) -> tuple[int, int]:
     x = np.radians(lon)
     y = np.arcsinh(np.tan(np.radians(lat)))
     x = (1 + x / np.pi) / 2

geo_activity_playground/explorer/converters.py

@@ -19,25 +19,26 @@ def explorer_per_activity_cache_dir() -> pathlib.Path:
     return path
 
 
-def get_first_tiles(id, repository: ActivityRepository) -> pd.DataFrame:
-    target_path = explorer_per_activity_cache_dir() / f"{id}.parquet"
+def get_first_tiles(id, repository: ActivityRepository, zoom: int) -> pd.DataFrame:
+    target_path = explorer_per_activity_cache_dir() / str(zoom) / f"{id}.parquet"
     if target_path.exists():
         return pd.read_parquet(target_path)
     else:
         logger.info(f"Extracting tiles from activity {id} …")
         time_series = repository.get_time_series(id)
-        tiles = tiles_from_points(time_series)
+        tiles = tiles_from_points(time_series, zoom)
         first_tiles = first_time_per_tile(tiles)
+        target_path.parent.mkdir(exist_ok=True, parents=True)
         first_tiles.to_parquet(target_path)
         return first_tiles
 
 
-def tiles_from_points(points: pd.DataFrame) -> pd.DataFrame:
+def tiles_from_points(points: pd.DataFrame, zoom: int) -> pd.DataFrame:
     assert pd.api.types.is_dtype_equal(points["time"].dtype, "datetime64[ns, UTC]")
     new_rows = []
     for index, row in points.iterrows():
         if "latitude" in row.keys() and "longitude" in row.keys():
-            tile = compute_tile(row["latitude"], row["longitude"])
+            tile = compute_tile(row["latitude"], row["longitude"], zoom)
             new_rows.append((row["time"],) + tile)
     return pd.DataFrame(new_rows, columns=["time", "tile_x", "tile_y"])
 
@@ -48,17 +49,17 @@ def first_time_per_tile(tiles: pd.DataFrame) -> pd.DataFrame:
 
 
 @functools.cache
-def get_tile_history(repository: ActivityRepository) -> pd.DataFrame:
+def get_tile_history(repository: ActivityRepository, zoom: int) -> pd.DataFrame:
     logger.info("Building explorer tile history from all activities …")
 
-    cache_file = pathlib.Path("Cache/first_time_per_tile.parquet")
+    cache_file = pathlib.Path(f"Cache/first_time_per_tile_{zoom}.parquet")
     if cache_file.exists():
         tiles = pd.read_parquet(cache_file)
     else:
         tiles = pd.DataFrame()
 
     with work_tracker(
-        pathlib.Path("Cache/task_first_time_per_tile.json")
+        pathlib.Path(f"Cache/task_first_time_per_tile_{zoom}.json")
     ) as parsed_activities:
         for activity in repository.iter_activities(new_to_old=False):
             if activity.id in parsed_activities:
@@ -66,7 +67,7 @@ def get_tile_history(repository: ActivityRepository) -> pd.DataFrame:
             parsed_activities.add(activity.id)
 
             logger.info(f"Activity {activity.id} wasn't parsed yet, reading them …")
-            shard = get_first_tiles(activity.id, repository)
+            shard = get_first_tiles(activity.id, repository, zoom)
             shard["activity_id"] = activity.id
             if not len(shard):
                 continue

geo_activity_playground/explorer/grid_file.py

@@ -1,3 +1,4 @@
+import logging
 import pathlib
 from typing import Iterator
 
@@ -6,30 +7,45 @@ import gpxpy
 import numpy as np
 import pandas as pd
 import scipy.ndimage
+import sklearn.cluster
 
 from geo_activity_playground.core.activities import ActivityRepository
 from geo_activity_playground.core.tiles import get_tile_upper_left_lat_lon
 from geo_activity_playground.explorer.converters import get_tile_history
 
 
-def get_three_color_tiles(tiles: pd.DataFrame, repository: ActivityRepository) -> str:
+logger = logging.getLogger(__name__)
+
+
+def get_three_color_tiles(
+    tiles: pd.DataFrame, repository: ActivityRepository, zoom: int
+) -> str:
     # Create array with visited tiles.
-    a = np.zeros((2**14, 2**14), dtype=np.int8)
+    a = np.zeros((2**zoom, 2**zoom), dtype=np.int8)
     a[tiles["tile_x"], tiles["tile_y"]] = 1
 
-    # Get cluster tiles via erosion.
-    cluster = scipy.ndimage.binary_erosion(a)
-    a[cluster] = 2
+    tile_dict = {
+        elem: {"cluster": False, "square": False}
+        for elem in zip(tiles["tile_x"], tiles["tile_y"])
+    }
+
+    for x, y in tile_dict.keys():
+        if (
+            (x + 1, y) in tile_dict
+            and (x - 1, y) in tile_dict
+            and (x, y + 1) in tile_dict
+            and (x, y - 1) in tile_dict
+        ):
+            tile_dict[(x, y)]["cluster"] = True
 
     # Compute biggest square.
     square_size = 1
     biggest = None
-    tile_set = {elem for elem in zip(tiles["tile_x"], tiles["tile_y"])}
-    for x, y in sorted(tile_set):
+    for x, y in sorted(tile_dict):
         while True:
             for i in range(square_size):
                 for j in range(square_size):
-                    if (x + i, y + j) not in tile_set:
+                    if (x + i, y + j) not in tile_dict:
                         break
                 else:
                     continue
@@ -42,58 +58,94 @@ def get_three_color_tiles(tiles: pd.DataFrame, repository: ActivityRepository) -
 
     if biggest is not None:
         square_x, square_y, square_size = biggest
-        a[square_x : square_x + square_size, square_y : square_y + square_size] = 3
-
-    tile_metadata = {
-        (row["tile_x"], row["tile_y"]): {
-            "first_visit": row["time"].date().isoformat(),
-            "activity_id": row["activity_id"],
-            "activity_name": repository.get_activity_by_id(row["activity_id"]).name,
-        }
-        for index, row in tiles.iterrows()
-    }
-
-    # Find non-zero tiles.
-    border_x, border_y = np.where(a)
-    return geojson.dumps(
-        geojson.FeatureCollection(
-            features=[
-                make_explorer_tile(
-                    x,
-                    y,
-                    {
-                        "color": {1: "red", 2: "green", 3: "blue"}[a[x, y]],
-                        **tile_metadata[(x, y)],
-                    },
-                )
-                for x, y in zip(border_x, border_y)
-            ]
+        for x in range(square_x, square_x + square_size):
+            for y in range(square_y, square_y + square_size):
+                tile_dict[(x, y)]["square"] = True
+
+    for index, row in tiles.iterrows():
+        tile_dict[(row["tile_x"], row["tile_y"])].update(
+            {
+                "first_visit": row["time"].date().isoformat(),
+                "activity_id": row["activity_id"],
+                "activity_name": repository.get_activity_by_id(row["activity_id"]).name,
+                "color": map_color(tile_dict[(row["tile_x"], row["tile_y"])]),
+            }
         )
+
+    num_cluster_tiles = sum(value["cluster"] for value in tile_dict.values())
+
+    cluster_tiles = np.array(
+        [tile for tile, value in tile_dict.items() if value["cluster"]]
     )
 
+    logger.info("Run DBSCAN cluster finding algorithm …")
+    dbscan = sklearn.cluster.DBSCAN(eps=1.1, min_samples=1)
+    labels = dbscan.fit_predict(cluster_tiles)
+    label_counts = dict(zip(*np.unique(labels, return_counts=True)))
+    max_cluster_size = max(
+        count for label, count in label_counts.items() if label != -1
+    )
+    for xy, label in zip(cluster_tiles, labels):
+        tile_dict[tuple(xy)]["cluster_id"] = int(label)
+        tile_dict[tuple(xy)]["this_cluster_size"] = int(label_counts[label])
 
-def get_border_tiles(tiles: pd.DataFrame) -> list[list[list[float]]]:
-    a = np.zeros((2**14, 2**14), dtype=np.int8)
-    a[tiles["tile_x"], tiles["tile_y"]] = 1
-    dilated = scipy.ndimage.binary_dilation(a, iterations=2)
-    border = dilated - a
-    border_x, border_y = np.where(border)
-    return make_grid_points(zip(border_x, border_y))
+    # Find non-zero tiles.
+    result = {
+        "explored_geojson": geojson.dumps(
+            geojson.FeatureCollection(
+                features=[
+                    make_explorer_tile(
+                        x,
+                        y,
+                        tile_dict[(x, y)],
+                        zoom,
+                    )
+                    for (x, y), v in tile_dict.items()
+                ]
+            )
+        ),
+        "max_cluster_size": max_cluster_size,
+        "num_cluster_tiles": num_cluster_tiles,
+        "num_tiles": len(tile_dict),
+        "square_size": square_size,
+    }
+    return result
+
+
+def map_color(tile_meta: dict) -> str:
+    if tile_meta["square"]:
+        return "blue"
+    elif tile_meta["cluster"]:
+        return "green"
+    else:
+        return "red"
+
+
+def get_border_tiles(tiles: pd.DataFrame, zoom: int) -> list[list[list[float]]]:
+    tile_set = set(zip(tiles["tile_x"], tiles["tile_y"]))
+    border_tiles = set()
+    for x, y in tile_set:
+        for neighbor in [(x + 1, y), (x - 1, y), (x, y + 1), (x, y - 1)]:
+            if neighbor not in tile_set:
+                border_tiles.add(neighbor)
+    return make_grid_points(border_tiles, zoom)
 
 
-def get_explored_tiles(tiles: pd.DataFrame) -> list[list[list[float]]]:
-    return make_grid_points(zip(tiles["tile_x"], tiles["tile_y"]))
+def get_explored_tiles(tiles: pd.DataFrame, zoom: int) -> list[list[list[float]]]:
+    return make_grid_points(zip(tiles["tile_x"], tiles["tile_y"]), zoom)
 
 
-def make_explorer_tile(tile_x: int, tile_y: int, properties: dict) -> geojson.Feature:
+def make_explorer_tile(
+    tile_x: int, tile_y: int, properties: dict, zoom: int
+) -> geojson.Feature:
     corners = [
         get_tile_upper_left_lat_lon(*args)
         for args in [
-            (tile_x, tile_y, 14),
-            (tile_x + 1, tile_y, 14),
-            (tile_x + 1, tile_y + 1, 14),
-            (tile_x, tile_y + 1, 14),
-            (tile_x, tile_y, 14),
+            (tile_x, tile_y, zoom),
+            (tile_x + 1, tile_y, zoom),
+            (tile_x + 1, tile_y + 1, zoom),
+            (tile_x, tile_y + 1, zoom),
+            (tile_x, tile_y, zoom),
         ]
     ]
     return geojson.Feature(
@@ -103,16 +155,16 @@ def make_explorer_tile(tile_x: int, tile_y: int, properties: dict) -> geojson.Fe
 
 
 def make_grid_points(
-    tile_iterator: Iterator[tuple[int, int]]
+    tile_iterator: Iterator[tuple[int, int]], zoom: int
 ) -> list[list[list[float]]]:
     result = []
     for tile_x, tile_y in tile_iterator:
         tile = [
-            get_tile_upper_left_lat_lon(tile_x, tile_y, 14),
-            get_tile_upper_left_lat_lon(tile_x + 1, tile_y, 14),
-            get_tile_upper_left_lat_lon(tile_x + 1, tile_y + 1, 14),
-            get_tile_upper_left_lat_lon(tile_x, tile_y + 1, 14),
-            get_tile_upper_left_lat_lon(tile_x, tile_y, 14),
+            get_tile_upper_left_lat_lon(tile_x, tile_y, zoom),
+            get_tile_upper_left_lat_lon(tile_x + 1, tile_y, zoom),
+            get_tile_upper_left_lat_lon(tile_x + 1, tile_y + 1, zoom),
+            get_tile_upper_left_lat_lon(tile_x, tile_y + 1, zoom),
+            get_tile_upper_left_lat_lon(tile_x, tile_y, zoom),
         ]
         result.append(tile)
     return result
@@ -153,8 +205,8 @@ def make_grid_file_geojson(grid_points: list[list[list[float]]], stem: str) -> s
     return result
 
 
-def get_explored_geojson(repository: ActivityRepository) -> str:
-    tiles = get_tile_history(repository)
+def get_explored_geojson(repository: ActivityRepository, zoom: int) -> str:
+    tiles = get_tile_history(repository, zoom)
     return make_grid_file_geojson(
         make_grid_points(zip(tiles["tile_x"], tiles["tile_y"]))
     )

geo_activity_playground/heatmap.py

@@ -211,7 +211,7 @@ def generate_heatmaps_per_cluster(repository: ActivityRepository) -> None:
     del arrays
 
     logger.info("Compute tiles for each point …")
-    tiles = [compute_tile(lat, lon) for lat, lon in latlon]
+    tiles = [compute_tile(lat, lon, 14) for lat, lon in latlon]
 
     unique_tiles = set(tiles)
     unique_tiles_array = np.array(list(unique_tiles))

geo_activity_playground/importers/strava_api.py

@@ -4,22 +4,16 @@ import json
 import logging
 import pathlib
 import pickle
-import tomllib
 from typing import Any
 
 import pandas as pd
 from stravalib import Client
 from stravalib.exc import RateLimitExceeded
 
-
-logger = logging.getLogger(__name__)
+from geo_activity_playground.core.config import get_config
 
 
-@functools.cache
-def get_config() -> dict:
-    config_path = pathlib.Path("config.toml")
-    with open(config_path, "rb") as f:
-        return tomllib.load(f)
+logger = logging.getLogger(__name__)
 
 
 def get_state(path: pathlib.Path) -> Any:

geo_activity_playground/webui/activity_controller.py

@@ -19,6 +19,7 @@ class ActivityController:
         activity = self._repository.get_activity_by_id(id)
 
         time_series = self._repository.get_time_series(id)
+        time_series["distance/km"] = time_series["distance"] / 1000
         line_json = make_geojson_from_time_series(time_series)
 
         result = {
@@ -40,7 +41,9 @@ def distance_time_plot(time_series: pd.DataFrame) -> str:
     return (
         alt.Chart(time_series, title="Distance")
         .mark_line()
-        .encode(alt.X("time", title="Time"), alt.Y("distance", title="Distance / km"))
+        .encode(
+            alt.X("time", title="Time"), alt.Y("distance/km", title="Distance / km")
+        )
         .interactive()
         .to_json(format="vega")
     )

geo_activity_playground/webui/app.py

@@ -33,19 +33,21 @@ def webui_main(repository: ActivityRepository) -> None:
         return render_template("index.html.j2", **entry_controller.render())
 
     @app.route("/activity/<id>")
-    def activity(id: int):
+    def activity(id: str):
         return render_template(
             "activity.html.j2", **activity_controller.render_activity(int(id))
         )
 
     @app.route("/activity/<id>/track.json")
-    def activity_track(id: int):
+    def activity_track(id: str):
         plot = activity_track_plot(repository.get_time_series(int(id)))
         return plot
 
-    @app.route("/explorer")
-    def explorer():
-        return render_template("explorer.html.j2", **explorer_controller.render())
+    @app.route("/explorer/<zoom>")
+    def explorer(zoom: str):
+        return render_template(
+            "explorer.html.j2", **explorer_controller.render(int(zoom))
+        )
 
     @app.route("/summary-statistics")
     def summary_statistics():

geo_activity_playground/webui/explorer_controller.py

@@ -1,6 +1,7 @@
 import functools
 
 from geo_activity_playground.core.activities import ActivityRepository
+from geo_activity_playground.core.tiles import get_tile_upper_left_lat_lon
 from geo_activity_playground.explorer.converters import get_tile_history
 from geo_activity_playground.explorer.grid_file import get_border_tiles
 from geo_activity_playground.explorer.grid_file import get_explored_geojson
@@ -15,20 +16,28 @@ class ExplorerController:
         self._repository = repository
 
     @functools.cache
-    def render(self) -> dict:
-        tiles = get_tile_history(self._repository)
+    def render(self, zoom: int) -> dict:
+        tiles = get_tile_history(self._repository, zoom)
+        medians = tiles.median()
+        median_lat, median_lon = get_tile_upper_left_lat_lon(
+            medians["tile_x"], medians["tile_y"], zoom
+        )
 
-        explored_geojson = get_three_color_tiles(tiles, self._repository)
+        explored = get_three_color_tiles(tiles, self._repository, zoom)
 
-        points = get_border_tiles(tiles)
+        points = get_border_tiles(tiles, zoom)
         missing_tiles_geojson = make_grid_file_geojson(points, "missing_tiles")
         make_grid_file_gpx(points, "missing_tiles")
 
-        points = get_explored_tiles(tiles)
+        points = get_explored_tiles(tiles, zoom)
         explored_tiles_geojson = make_grid_file_geojson(points, "explored")
         make_grid_file_gpx(points, "explored")
 
         return {
-            "explored_geojson": explored_geojson,
+            "center": {
+                "latitude": median_lat,
+                "longitude": median_lon,
+            },
+            "explored": explored,
             "missing_tiles_geojson": missing_tiles_geojson,
         }

geo_activity_playground/webui/templates/explorer.html.j2

@@ -4,6 +4,11 @@
 <div class="row mb-3">
     <div class="col">
         <h1>Explorer Tiles</h1>
+        <p>You have {{ explored.num_tiles }} explored tiles. There are {{ explored.num_cluster_tiles }} cluster tiles in
+            total. Your largest cluster consists of {{ explored.max_cluster_size }} tiles. Your largest square has size
+            {{
+            explored.square_size }}².
+        </p>
     </div>
 </div>
 
@@ -22,14 +27,21 @@
         <script>
             function onEachFeature(feature, layer) {
                 if (feature.properties && feature.properties.first_visit) {
-                    layer.bindPopup(`First visited on ${feature.properties.first_visit} as part of <a href=/activity/${feature.properties.activity_id}>${feature.properties.activity_name}</a>.`)
+                    let lines = [`First visit: ${feature.properties.first_visit}`,
+                    `First activity: <a href=/activity/${feature.properties.activity_id}>${feature.properties.activity_name}</a>`]
+                    if (feature.properties.this_cluster_size) {
+                        lines.push(`This cluster size: ${feature.properties.this_cluster_size}`)
+                    }
+                    layer.bindPopup(lines.join('<br />'))
                 }
             }
 
-            let explorer_geojson = {{ explored_geojson| safe}}
+            let explorer_geojson = {{ explored.explored_geojson| safe}}
             let map = L.map('explorer-map', {
-                fullscreenControl: true
-            });
+                fullscreenControl: true,
+                center: [{{ center.latitude }}, {{ center.longitude }}],
+            zoom: 10
+            })
             L.tileLayer('https://tile.openstreetmap.org/{z}/{x}/{y}.png', {
                 maxZoom: 19,
                 attribution: '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a>'
@@ -38,7 +50,6 @@
                 style: function (feature) { return { color: feature.properties.color, fillColor: feature.properties.color, weight: 1 } },
                 onEachFeature: onEachFeature
             }).addTo(map)
-            map.fitBounds(explorer_layer.getBounds())
         </script>
     </div>
 </div>
@@ -59,14 +70,15 @@
         <script>
             let missing_geojson = {{ missing_tiles_geojson| safe}}
             let missing_map = L.map('missing-map', {
-                fullscreenControl: true
+                fullscreenControl: true,
+                center: [{{ center.latitude }}, {{ center.longitude }}],
+            zoom: 10
             });
             L.tileLayer('https://tile.openstreetmap.org/{z}/{x}/{y}.png', {
                 maxZoom: 19,
                 attribution: '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a>'
             }).addTo(missing_map)
             let missing_layer = L.geoJSON(missing_geojson).addTo(missing_map)
-            missing_map.fitBounds(missing_layer.getBounds())
         </script>
     </div>
 </div>

geo_activity_playground/webui/templates/heatmap.html.j2

@@ -15,7 +15,7 @@
             let map = L.map('heatmap', {
                 fullscreenControl: true,
                 center: [{{ center.latitude }}, {{ center.longitude }}],
-            zoom: 12
+                zoom: 12
             });
             L.tileLayer('/heatmap/tile/{z}/{x}/{y}.png', {
                 maxZoom: 19,

geo_activity_playground/webui/templates/page.html.j2

@@ -62,7 +62,10 @@
                             <a class="nav-link active" aria-current="page" href="/calendar">Calendar</a>
                         </li>
                         <li class="nav-item">
-                            <a class="nav-link active" aria-current="page" href="/explorer">Explorer</a>
+                            <a class="nav-link active" aria-current="page" href="/explorer/14">Explorer</a>
+                        </li>
+                        <li class="nav-item">
+                            <a class="nav-link active" aria-current="page" href="/explorer/17">Squadratinhos</a>
                         </li>
                         <li class="nav-item">
                             <a class="nav-link active" aria-current="page" href="/heatmap">Heatmap</a>

{geo_activity_playground-0.6.0.dist-info → geo_activity_playground-0.8.0.dist-info}/METADATA

@@ -1,13 +1,14 @@
 Metadata-Version: 2.1
 Name: geo-activity-playground
-Version: 0.6.0
+Version: 0.8.0
 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.12
+Requires-Python: >=3.9,<3.12
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Requires-Dist: Pillow (>=9.2.0,<10.0.0)
@@ -27,6 +28,7 @@ Requires-Dist: requests (>=2.28.1,<3.0.0)
 Requires-Dist: scikit-learn (>=1.3.0,<2.0.0)
 Requires-Dist: scipy (>=1.8.1,<2.0.0)
 Requires-Dist: stravalib (>=1.3.3,<2.0.0)
+Requires-Dist: tomli (>=2.0.1,<3.0.0) ; python_version < "3.11"
 Requires-Dist: tqdm (>=4.64.0,<5.0.0)
 Requires-Dist: vegafusion (>=1.4.3,<2.0.0)
 Requires-Dist: vegafusion-python-embed (>=1.4.3,<2.0.0)

{geo_activity_playground-0.6.0.dist-info → geo_activity_playground-0.8.0.dist-info}/RECORD

@@ -1,29 +1,30 @@
 geo_activity_playground/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-geo_activity_playground/__main__.py,sha256=0xUcQkoRcPhLJX3uluIFs1GtRRdaqqz6GVAR8UNDmmI,3151
+geo_activity_playground/__main__.py,sha256=bGDI5TTWJakCBqlet-kqdDOmBgh9JbmV7v99g6GgT3A,2745
 geo_activity_playground/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-geo_activity_playground/core/activities.py,sha256=LnT9vZgt7lkim6T9pVHxtF8MjFIivmSqCqiR5YMuuBU,4237
+geo_activity_playground/core/activities.py,sha256=6f-pnIJ58ZMrcwXJ19LJUafmip9vUVPlGyBeVUVnIxw,4484
 geo_activity_playground/core/activity_parsers.py,sha256=CaQB4jXm-4PjrXR7AcLkgZt82zGl4oCyLYlY0Zfx4H8,2135
+geo_activity_playground/core/config.py,sha256=GNHEIeFI3dNRiFSMburn5URZHx0qkiitvePAx2toYUQ,456
 geo_activity_playground/core/coordinates.py,sha256=SxU2xDPZD-KxL2VBM94_wUFKkcG27-wTLkuu22ByVps,573
 geo_activity_playground/core/heatmap.py,sha256=BPhRNcieHgc5gSZdKRtYcv8Ljfwgi-teLr6VVBVlTkg,1289
 geo_activity_playground/core/plots.py,sha256=7FX1QRT_haBq9lQsehaZQ_rXLcJNHO2Fx_bWuBXwPnw,2420
 geo_activity_playground/core/sources.py,sha256=_eZE_JHlOP0oMRkpXMjfGTBPSkWEfMzPovosc5QrSCE,188
 geo_activity_playground/core/tasks.py,sha256=vV8fOmBeIx0t_qXW5qvQ2Ut0JiAw6XZ-y_y9ZUkZJAA,301
 geo_activity_playground/core/test_tiles.py,sha256=ATIcCqwAQMpkPAZD9VO__uinpuuOyz4z2fAy2vpoMH8,410
-geo_activity_playground/core/tiles.py,sha256=0tmnDZmTz5vJyf4jqIYneTBpHOD50RdS2FREb0ckwXc,2404
+geo_activity_playground/core/tiles.py,sha256=aTC3roH8JMaEAMC_hUAwOz7_Yvvw7n4Vc-9y8pN05Pk,2399
 geo_activity_playground/explorer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-geo_activity_playground/explorer/converters.py,sha256=wF2eYuo2IQ-F2kmJc25KzRtO9QE6z6dyMxvDnqvcM3U,2910
-geo_activity_playground/explorer/grid_file.py,sha256=ae2ZvqpMHbmKIXg8U_jQcQEe66yBT8evlf0f5JXVas0,5166
+geo_activity_playground/explorer/converters.py,sha256=UVU5qhnvAelY6rmqCnkqfDp1zYI_1LUatdJC0d16BWE,3051
+geo_activity_playground/explorer/grid_file.py,sha256=lER2TAJjsG8BMjbdoXiwW9GXZLM8bH-9EeF7z7yckgg,6828
 geo_activity_playground/explorer/video.py,sha256=RGZik93ghfZuRILXf8pfUbPh5VV37_QRAR4FgOMfZqQ,4354
-geo_activity_playground/heatmap.py,sha256=EO-8eOVZ8eHJe0aqHWqKymhjvnBGyPUhwFzdXtV8vBU,8548
+geo_activity_playground/heatmap.py,sha256=jg0yuFvYoSa8K0uGL6MCMhWFclXWO3DVyrsdSJcH380,8552
 geo_activity_playground/importers/directory.py,sha256=Hk9YYJA2ssWaOyc6WFxKNwTo5DWZxXCW661spCyI7kQ,2622
-geo_activity_playground/importers/strava_api.py,sha256=vacbspe0vR8e3duav1KOBB-ODebSOV_hF5RWMzNojOo,5865
-geo_activity_playground/webui/activity_controller.py,sha256=JMLLsh26SdwBkvOUEvKK-w05ZulPXlFOfxRRFdEU4w4,2848
-geo_activity_playground/webui/app.py,sha256=DZzd10EONXHN0nAmsLFJ0BGcKw8RNQLuOV-q2Z28bDg,3485
+geo_activity_playground/importers/strava_api.py,sha256=3utIYnmw0nqY5oGBf-3VJPzGI1hTplYUfeWXoSuJ7gE,5749
+geo_activity_playground/webui/activity_controller.py,sha256=sOYUYJGibYx6eGOxE17umSWubpybB8Xgcm07wB0v4LA,2941
+geo_activity_playground/webui/app.py,sha256=9-TgDI1LojplwPxeorMqtObGWIw1sB5qepqWVHUl3s4,3532
 geo_activity_playground/webui/calendar_controller.py,sha256=maQ1RlrD99pncOts3ue5ye4OHr6WB-E40eAzs8ZxwPI,2239
 geo_activity_playground/webui/eddington_controller.py,sha256=b5mYkciv7Wkd5zord-WsdrV_8c-qpVi-8DG3jIUEKhs,2616
 geo_activity_playground/webui/entry_controller.py,sha256=TixdwCDMKhHUVrbc6sAIjpvtmouHXtbQN0N641TB__s,1851
 geo_activity_playground/webui/equipment_controller.py,sha256=2asTMDEYdMz8a_l5fXL1ULXoUaDHywoDl9mZnfZSn5Q,2011
-geo_activity_playground/webui/explorer_controller.py,sha256=UBt6aGsexZwz-1gw3UOAWAv-ek-bdI5nbweZTszvTZ0,1400
+geo_activity_playground/webui/explorer_controller.py,sha256=8OD9h7-UzlSU53tpA7LD0VsHbvRTka9U4CFjiuNQzGU,1766
 geo_activity_playground/webui/heatmap_controller.py,sha256=twfp9IQwUz9qQCjO0zMwhWjQYmHRpHM-A8BPnCj3ErY,3636
 geo_activity_playground/webui/static/android-chrome-192x192.png,sha256=30rNfBHxdLYC0Wx4cDkPZY-V17ZQZIc4PPLQBdz_w1U,20069
 geo_activity_playground/webui/static/android-chrome-384x384.png,sha256=bgeqAdyvDZBMch7rVi3qSawf0Zr4Go0EG8Ws_B8NApY,49297
@@ -40,12 +41,12 @@ geo_activity_playground/webui/templates/calendar-month.html.j2,sha256=LVokl95lPl
 geo_activity_playground/webui/templates/calendar.html.j2,sha256=b7a_YWhqyN2GYU7g4wIckU3UURTzNuL5fGe5SibVKM8,1099
 geo_activity_playground/webui/templates/eddington.html.j2,sha256=yl75IzWeIkFpwPj8FjTrzJsz_f-qdETPmNnAGLPJuL8,487
 geo_activity_playground/webui/templates/equipment.html.j2,sha256=BwZzbZ2AuFuiM_Fxu2KOqvhcgHd9yr1xL76ihb_6YKc,1317
-geo_activity_playground/webui/templates/explorer.html.j2,sha256=RR6Odp8dWHmOUzrXfFjVV3_BKvWnXDeOk4URpKwmSCk,2747
-geo_activity_playground/webui/templates/heatmap.html.j2,sha256=H4Jd1eSjDr9lu-ni9I1ErFoXQLbZiyP5NnKYpmHLizY,722
+geo_activity_playground/webui/templates/explorer.html.j2,sha256=fVxPxicgDRvgOu1138E6bJs81CFvf1VkHuzGYAWW1ok,3399
+geo_activity_playground/webui/templates/heatmap.html.j2,sha256=M56IKATu3TdlwXUgTK9w-vfoAubBv9oJrE3ot-wEf84,726
 geo_activity_playground/webui/templates/index.html.j2,sha256=6b0cdqiGnqrC_hjEg-z6-IZFqXoZa7V0JurQ4Xd6YJw,1968
-geo_activity_playground/webui/templates/page.html.j2,sha256=Mg-T7npU7PFcBDpJLAkHprK52QDZtQ0xkvFl1HEkx5Q,4912
+geo_activity_playground/webui/templates/page.html.j2,sha256=CWaDxYlXzJCWCuIsMma2-PCLrsEr38cSan01CGG00qU,5104
 geo_activity_playground/webui/templates/summary-statistics.html.j2,sha256=WylEkNplyXIt2bqYdZg93xupeP9wmaq5AWnpYaPkr-8,453
-geo_activity_playground-0.6.0.dist-info/METADATA,sha256=nk86mMHCs4vqSUD_m22QiqQSYP4_JMVHqSpkyPGhim0,1312
-geo_activity_playground-0.6.0.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
-geo_activity_playground-0.6.0.dist-info/entry_points.txt,sha256=pbNlLI6IIZIp7nPYCfAtiSiz2oxJSCl7DODD6SPkLKk,81
-geo_activity_playground-0.6.0.dist-info/RECORD,,
+geo_activity_playground-0.8.0.dist-info/METADATA,sha256=lAYsRY6bF3_FhEX9MODLVrJvQH-SuP25fEppUVkqPH0,1425
+geo_activity_playground-0.8.0.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
+geo_activity_playground-0.8.0.dist-info/entry_points.txt,sha256=pbNlLI6IIZIp7nPYCfAtiSiz2oxJSCl7DODD6SPkLKk,81
+geo_activity_playground-0.8.0.dist-info/RECORD,,