geo-activity-playground 0.30.0__tar.gz → 0.32.0__tar.gz

{geo_activity_playground-0.30.0 → geo_activity_playground-0.32.0}/PKG-INFO

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

{geo_activity_playground-0.30.0 → geo_activity_playground-0.32.0}/geo_activity_playground/core/activities.py

@@ -1,5 +1,6 @@
 import datetime
 import functools
+import json
 import logging
 import pickle
 from typing import Any
@@ -16,6 +17,7 @@ from tqdm import tqdm
 from geo_activity_playground.core.paths import activities_file
 from geo_activity_playground.core.paths import activity_enriched_meta_dir
 from geo_activity_playground.core.paths import activity_enriched_time_series_dir
+from geo_activity_playground.core.paths import activity_meta_override_dir
 
 logger = logging.getLogger(__name__)
 
@@ -83,7 +85,12 @@ def build_activity_meta() -> None:
     rows = []
     for new_id in tqdm(new_ids, desc="Register new activities"):
         with open(activity_enriched_meta_dir() / f"{new_id}.pickle", "rb") as f:
-            rows.append(pickle.load(f))
+            data = pickle.load(f)
+        override_file = activity_meta_override_dir() / f"{new_id}.json"
+        if override_file.exists():
+            with open(override_file) as f:
+                data.update(json.load(f))
+        rows.append(data)
 
     if rows:
         new_shard = pd.DataFrame(rows)
@@ -140,7 +147,6 @@ class ActivityRepository:
             if not dropna or not pd.isna(row["start"]):
                 yield row
 
-    @functools.lru_cache()
     def get_activity_by_id(self, id: int) -> ActivityMeta:
         activity = self.meta.loc[id]
         assert isinstance(activity["name"], str), activity["name"]
@@ -158,6 +164,9 @@ class ActivityRepository:
 
         return df
 
+    def save(self) -> None:
+        self._meta.to_parquet(activities_file())
+
 
 def make_geojson_from_time_series(time_series: pd.DataFrame) -> str:
     fc = geojson.FeatureCollection(

{geo_activity_playground-0.30.0 → geo_activity_playground-0.32.0}/geo_activity_playground/core/config.py

@@ -29,6 +29,7 @@ class Config:
     )
     heart_rate_resting: int = 0
     heart_rate_maximum: Optional[int] = None
+    ignore_suffixes: list[str] = dataclasses.field(default_factory=list)
     kind_renames: dict[str, str] = dataclasses.field(default_factory=dict)
     kinds_without_achievements: list[str] = dataclasses.field(default_factory=list)
     metadata_extraction_regexes: list[str] = dataclasses.field(default_factory=list)

{geo_activity_playground-0.30.0 → geo_activity_playground-0.32.0}/geo_activity_playground/core/heatmap.py

@@ -142,6 +142,69 @@ def build_map_from_tiles(tile_bounds: TileBounds) -> np.ndarray:
     return background
 
 
+def build_map_from_tiles_around_center(
+    center: tuple[float, float],
+    zoom: int,
+    target: tuple[int, int],
+    inner_target: tuple[int, int],
+) -> np.ndarray:
+    background = np.zeros((target[1], target[0], 3))
+
+    # We will work with the center point and have it in terms of tiles `t` and also in terms of pixels `p`. At the start we know that the tile center must be in the middle of the image.
+    t = np.array(center)
+    p = np.array([inner_target[0] / 2, inner_target[1] / 2])
+
+    # Shift both such that they are in the top-left corner of an even tile.
+    t_offset = np.array([center[0] % 1, center[1] % 1])
+    t -= t_offset
+    p -= t_offset * OSM_TILE_SIZE
+
+    # Shift until we have left the image.
+    shift = np.ceil(p / OSM_TILE_SIZE)
+    p -= shift * OSM_TILE_SIZE
+    t -= shift
+
+    num_tiles = np.ceil(np.array(target) / OSM_TILE_SIZE) + 1
+
+    for x in range(int(t[0]), int(t[0] + num_tiles[0])):
+        for y in range(int(t[1]), int(t[1]) + int(num_tiles[1])):
+            source_x_min = 0
+            source_y_min = 0
+            source_x_max = source_x_min + OSM_TILE_SIZE
+            source_y_max = source_y_min + OSM_TILE_SIZE
+
+            target_x_min = (x - int(t[0])) * OSM_TILE_SIZE + int(p[0])
+            target_y_min = (y - int(t[1])) * OSM_TILE_SIZE + int(p[1])
+            target_x_max = target_x_min + OSM_TILE_SIZE
+            target_y_max = target_y_min + OSM_TILE_SIZE
+
+            if target_x_min < 0:
+                source_x_min -= target_x_min
+                target_x_min = 0
+            if target_y_min < 0:
+                source_y_min -= target_y_min
+                target_y_min = 0
+            if target_x_max > target[0]:
+                a = target_x_max - target[0]
+                target_x_max -= a
+                source_x_max -= a
+            if target_y_max > target[1]:
+                a = target_y_max - target[1]
+                target_y_max -= a
+                source_y_max -= a
+
+            if source_x_max < 0 or source_y_max < 0:
+                continue
+
+            tile = np.array(get_tile(zoom, x, y)) / 255
+
+            background[target_y_min:target_y_max, target_x_min:target_x_max] = tile[
+                source_y_min:source_y_max, source_x_min:source_x_max, :3
+            ]
+
+    return background
+
+
 def convert_to_grayscale(image: np.ndarray) -> np.ndarray:
     image = np.sum(image * [0.2126, 0.7152, 0.0722], axis=2)
     image = np.dstack((image, image, image))

{geo_activity_playground-0.30.0 → geo_activity_playground-0.32.0}/geo_activity_playground/core/paths.py

@@ -53,6 +53,8 @@ _strava_last_activity_date_path = _cache_dir / "strava-last-activity-date.json"
 
 _new_config_file = pathlib.Path("config.json")
 
+_activity_meta_override_dir = pathlib.Path("Metadata Override")
+
 
 cache_dir = dir_wrapper(_cache_dir)
 
@@ -63,6 +65,7 @@ activity_enriched_meta_dir = dir_wrapper(_activity_enriched_meta_dir)
 activity_enriched_time_series_dir = dir_wrapper(_activity_enriched_time_series_dir)
 tiles_per_time_series = dir_wrapper(_tiles_per_time_series)
 strava_api_dir = dir_wrapper(_strava_api_dir)
+activity_meta_override_dir = dir_wrapper(_activity_meta_override_dir)
 
 activities_file = file_wrapper(_activities_file)
 strava_dynamic_config_path = file_wrapper(_strava_dynamic_config_path)

{geo_activity_playground-0.30.0 → geo_activity_playground-0.32.0}/geo_activity_playground/importers/directory.py

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

geo_activity_playground-0.32.0/geo_activity_playground/webui/activity/blueprint.py

@@ -0,0 +1,109 @@
+import json
+import urllib.parse
+from collections.abc import Collection
+
+from flask import Blueprint
+from flask import redirect
+from flask import render_template
+from flask import request
+from flask import Response
+from flask import url_for
+
+from ...core.activities import ActivityRepository
+from ...explorer.tile_visits import TileVisitAccessor
+from .controller import ActivityController
+from geo_activity_playground.core.config import Config
+from geo_activity_playground.core.paths import activity_meta_override_dir
+from geo_activity_playground.core.privacy_zones import PrivacyZone
+from geo_activity_playground.webui.authenticator import Authenticator
+from geo_activity_playground.webui.authenticator import needs_authentication
+
+
+def make_activity_blueprint(
+    repository: ActivityRepository,
+    tile_visit_accessor: TileVisitAccessor,
+    config: Config,
+    authenticator: Authenticator,
+) -> Blueprint:
+    blueprint = Blueprint("activity", __name__, template_folder="templates")
+
+    activity_controller = ActivityController(repository, tile_visit_accessor, config)
+
+    @blueprint.route("/all")
+    def all():
+        return render_template(
+            "activity/lines.html.j2", **activity_controller.render_all()
+        )
+
+    @blueprint.route("/<id>")
+    def show(id: str):
+        return render_template(
+            "activity/show.html.j2", **activity_controller.render_activity(int(id))
+        )
+
+    @blueprint.route("/<id>/sharepic.png")
+    def sharepic(id: str):
+        return Response(
+            activity_controller.render_sharepic(int(id)),
+            mimetype="image/png",
+        )
+
+    @blueprint.route("/day/<year>/<month>/<day>")
+    def day(year: str, month: str, day: str):
+        return render_template(
+            "activity/day.html.j2",
+            **activity_controller.render_day(int(year), int(month), int(day)),
+        )
+
+    @blueprint.route("/name/<name>")
+    def name(name: str):
+        return render_template(
+            "activity/name.html.j2",
+            **activity_controller.render_name(urllib.parse.unquote(name)),
+        )
+
+    @blueprint.route("/edit/<id>", methods=["GET", "POST"])
+    @needs_authentication(authenticator)
+    def edit(id: str):
+        activity_id = int(id)
+        activity = repository.get_activity_by_id(activity_id)
+        override_file = activity_meta_override_dir() / f"{activity_id}.json"
+        if override_file.exists():
+            with open(override_file) as f:
+                override = json.load(f)
+        else:
+            override = {}
+
+        if request.method == "POST":
+            override = {}
+            if value := request.form.get("name"):
+                override["name"] = value
+                repository.meta.loc[activity_id, "name"] = value
+            if value := request.form.get("kind"):
+                override["kind"] = value
+                repository.meta.loc[activity_id, "kind"] = value
+            if value := request.form.get("equipment"):
+                override["equipment"] = value
+                repository.meta.loc[activity_id, "equipment"] = value
+            if value := request.form.get("commute"):
+                override["commute"] = True
+                repository.meta.loc[activity_id, "commute"] = True
+            if value := request.form.get("consider_for_achievements"):
+                override["consider_for_achievements"] = True
+                repository.meta.loc[activity_id, "consider_for_achievements"] = True
+
+            with open(override_file, "w") as f:
+                json.dump(override, f, ensure_ascii=False, indent=4, sort_keys=True)
+
+            repository.save()
+
+            return redirect(url_for(".show", id=activity_id))
+
+        return render_template(
+            "activity/edit.html.j2",
+            activity_id=activity_id,
+            activity=activity,
+            override=override,
+        )
+
+    return blueprint

{geo_activity_playground-0.30.0 → geo_activity_playground-0.32.0}/geo_activity_playground/webui/activity/controller.py

@@ -23,9 +23,11 @@ from geo_activity_playground.core.config import Config
 from geo_activity_playground.core.heart_rate import HeartRateZoneComputer
 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 build_map_from_tiles_around_center
 from geo_activity_playground.core.heatmap import GeoBounds
 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_MAX_ZOOM
 from geo_activity_playground.core.heatmap import OSM_TILE_SIZE
 from geo_activity_playground.core.heatmap import PixelBounds
 from geo_activity_playground.core.heatmap import TileBounds
@@ -459,42 +461,55 @@ def make_sharepic(
     time_series: pd.DataFrame,
     sharepic_suppressed_fields: list[str],
 ) -> bytes:
-    lat_lon_data = np.array([time_series["latitude"], time_series["longitude"]]).T
+    tile_x = time_series["x"]
+    tile_y = time_series["y"]
+    tile_width = tile_x.max() - tile_x.min()
+    tile_height = tile_y.max() - tile_y.min()
+
+    target_width = 600
+    target_height = 600
+    footer_height = 100
+    target_map_height = target_height - footer_height
+
+    zoom = int(
+        min(
+            np.log2(target_width / tile_width / OSM_TILE_SIZE),
+            np.log2(target_map_height / tile_height / OSM_TILE_SIZE),
+            OSM_MAX_ZOOM,
+        )
+    )
 
-    geo_bounds = get_bounds(lat_lon_data)
-    geo_bounds = add_margin_to_geo_bounds(geo_bounds)
-    tile_bounds = get_sensible_zoom_level(geo_bounds, (1500, 1500))
-    tile_bounds = make_tile_bounds_square(tile_bounds)
-    background = build_map_from_tiles(tile_bounds)
-    # background = convert_to_grayscale(background)
+    tile_xz = tile_x * 2**zoom
+    tile_yz = tile_y * 2**zoom
 
-    crop_mask = get_crop_mask(geo_bounds, tile_bounds)
-    assert pixels_in_bounds(crop_mask) <= 10_000_000, crop_mask
+    tile_xz_center = (
+        (tile_xz.max() + tile_xz.min()) / 2,
+        (tile_yz.max() + tile_yz.min()) / 2,
+    )
 
-    background = background[
-        crop_mask.y_min : crop_mask.y_max,
-        crop_mask.x_min : crop_mask.x_max,
-        :,
-    ]
+    background = build_map_from_tiles_around_center(
+        tile_xz_center,
+        zoom,
+        (target_width, target_height),
+        (target_width, target_map_height),
+    )
 
     img = Image.fromarray((background * 255).astype("uint8"), "RGB")
     draw = ImageDraw.Draw(img, mode="RGBA")
 
     for _, group in time_series.groupby("segment_id"):
-        xs, ys = compute_tile_float(
-            group["latitude"], group["longitude"], tile_bounds.zoom
-        )
         yx = list(
-            (
-                int((x - tile_bounds.x_tile_min) * OSM_TILE_SIZE - crop_mask.x_min),
-                int((y - tile_bounds.y_tile_min) * OSM_TILE_SIZE - crop_mask.y_min),
+            zip(
+                (tile_xz - tile_xz_center[0]) * OSM_TILE_SIZE + target_width / 2,
+                (tile_yz - tile_xz_center[1]) * OSM_TILE_SIZE + target_map_height / 2,
             )
-            for x, y in zip(xs, ys)
         )
 
         draw.line(yx, fill="red", width=4)
 
-    draw.rectangle([0, img.height - 70, img.width, img.height], fill=(0, 0, 0, 128))
+    draw.rectangle(
+        [0, img.height - footer_height, img.width, img.height], fill=(0, 0, 0, 180)
+    )
 
     facts = {
         "kind": f"{activity['kind']}",
@@ -515,19 +530,20 @@ def make_sharepic(
         if not key in sharepic_suppressed_fields
     }
 
-    draw.text((35, img.height - 70 + 10), "      ".join(facts.values()), font_size=20)
-
-    # img_array = np.array(img) / 255
-
-    # weight = np.dstack([img_array[:, :, 0]] * 3)
+    draw.text(
+        (35, img.height - footer_height + 10),
+        "      ".join(facts.values()),
+        font_size=20,
+    )
 
-    # background = (1 - weight) * background + img_array
-    # background[background > 1.0] = 1.0
-    # background[background < 0.0] = 0.0
+    draw.text(
+        (img.width - 250, img.height - 20),
+        "Map: © Open Street Map Contributors",
+        font_size=14,
+    )
 
     f = io.BytesIO()
     img.save(f, format="png")
-    # pl.imsave(f, background, format="png")
     return bytes(f.getbuffer())
 
 

{geo_activity_playground-0.30.0 → geo_activity_playground-0.32.0}/geo_activity_playground/webui/activity/templates/activity/day.html.j2

@@ -58,9 +58,9 @@
                     <td><span style="color: {{ activity['color'] }};">█</span> <a
                             href="{{ url_for('activity.show', id=activity.id) }}">{{
                             activity.name }}</a></td>
-                    <td>{{ activity.start }}</td>
+                    <td>{{ activity.start|dt }}</td>
                     <td>{{ activity.distance_km | round(1) }}</td>
-                    <td>{{ activity.elapsed_time }}</td>
+                    <td>{{ activity.elapsed_time|td }}</td>
                     <td>{{ activity["equipment"] }}</td>
                     <td>{{ activity["kind"] }}</td>
                 </tr>
@@ -70,7 +70,7 @@
                     <td><b>Total</b></td>
                     <td></td>
                     <td><b>{{ total_distance | round(1) }}</b></td>
-                    <td><b>{{ total_elapsed_time }}</b></td>
+                    <td><b>{{ total_elapsed_time|td }}</b></td>
                     <td></td>
                     <td></td>
                 </tr>

geo_activity_playground-0.32.0/geo_activity_playground/webui/activity/templates/activity/edit.html.j2

@@ -0,0 +1,42 @@
+{% extends "page.html.j2" %}
+
+{% block container %}
+
+<h1 class="mb-3">Edit Activity</h1>
+
+<form method="POST">
+    <div class="mb-3">
+        <label for="name" class="form-label">Name</label>
+        <input type="text" class="form-control" id="name" name="name" value="{{ override['name'] }}" />
+    </div>
+
+    <div class="mb-3">
+        <label for="kind" class="form-label">Kind</label>
+        <input type="text" class="form-control" id="kind" name="kind" value="{{ override['kind'] }}" />
+    </div>
+
+    <div class="mb-3">
+        <label for="equipment" class="form-label">Equipment</label>
+        <input type="text" class="form-control" id="equipment" name="equipment" value="{{ override['equipment'] }}" />
+    </div>
+
+    <div class="mb-3">
+        <div class="form-check">
+            <input type="checkbox" class="form-check-input" id="commute" name="commute" {% if override['commute'] %}
+                checked {% endif %} />
+            <label for="commute" class="form-check-label">Commute</label>
+        </div>
+    </div>
+
+    <div class="mb-3">
+        <div class="form-check">
+            <input type="checkbox" class="form-check-input" id="consider_for_achievements"
+                name="consider_for_achievements" {% if override['consider_for_achievements'] %} checked {% endif %} />
+            <label for="consider_for_achievements" class="form-check-label">Consider for achievements</label>
+        </div>
+    </div>
+
+    <button type="submit" class="btn btn-primary">Save</button>
+</form>
+
+{% endblock %}

{geo_activity_playground-0.30.0 → geo_activity_playground-0.32.0}/geo_activity_playground/webui/activity/templates/activity/name.html.j2

@@ -66,9 +66,9 @@
                 <tr>
                     <td><span style="color: {{ activity['color'] }};">█</span> <a href="{{ url_for('activity.show', id=activity.id) }}">{{
                             activity.name }}</a></td>
-                    <td>{{ activity.start }}</td>
+                    <td>{{ activity.start|dt }}</td>
                     <td>{{ activity.distance_km | round(1) }}</td>
-                    <td>{{ activity.elapsed_time }}</td>
+                    <td>{{ activity.elapsed_time|td }}</td>
                     <td>{{ activity["equipment"] }}</td>
                     <td>{{ activity["kind"] }}</td>
                 </tr>

{geo_activity_playground-0.30.0 → geo_activity_playground-0.32.0}/geo_activity_playground/webui/activity/templates/activity/show.html.j2

@@ -19,9 +19,9 @@
             <dt>Distance</dt>
             <dd>{{ activity.distance_km|round(1) }} km</dd>
             <dt>Elapsed time</dt>
-            <dd>{{ activity.elapsed_time }}</dd>
+            <dd>{{ activity.elapsed_time|td }}</dd>
             <dt>Moving time</dt>
-            <dd>{{ activity.moving_time }}</dd>
+            <dd>{{ activity.moving_time|td }}</dd>
             <dt>Start time</dt>
             <dd><a href="{{ url_for('activity.day', year=date.year, month=date.month, day=date.day) }}">{{ date }}</a>
                 {{ time }}
@@ -31,7 +31,7 @@
             <dt>Steps</dt>
             <dd>{{ activity.steps }}</dd>
             <dt>Equipment</dt>
-            <dd>{{ activity.equipment }}</dd>
+            <dd>{{ activity['equipment'] }}</dd>
             <dt>New Explorer Tiles</dt>
             <dd>{{ new_tiles[14] }}</dd>
             <dt>New Squadratinhos</dt>
@@ -41,6 +41,8 @@
             <dt>Source path</dt>
             <dd>{{ activity.path }}</dd>
         </dl>
+
+        <a href="{{ url_for('.edit', id=activity['id']) }}" class="btn btn-secondary btn-small">Edit metadata</a>
     </div>
     <div class="col-8">
         <div id="activity-map" style="height: 500px;" class="mb-3"></div>
@@ -201,10 +203,10 @@
             <tbody>
                 {% for other_activity in similar_activites %}
                 <tr>
-                    <td><a href="{{ url_for('.show', id=other_activity.id) }}">{{ other_activity.start
+                    <td><a href="{{ url_for('.show', id=other_activity.id) }}">{{ other_activity.start|dt
                             }}</a></td>
                     <td>{{ other_activity.distance_km | round(1) }}</td>
-                    <td>{{ other_activity.elapsed_time }}</td>
+                    <td>{{ other_activity.elapsed_time|td }}</td>
                     <td>{{ other_activity["equipment"] }}</td>
                     <td>{{ other_activity["kind"] }}</td>
                 </tr>

{geo_activity_playground-0.30.0 → geo_activity_playground-0.32.0}/geo_activity_playground/webui/app.py

@@ -1,3 +1,4 @@
+import datetime
 import importlib
 import json
 import pathlib
@@ -60,6 +61,18 @@ def web_ui_main(
     app.config["UPLOAD_FOLDER"] = "Activities"
     app.secret_key = get_secret_key()
 
+    @app.template_filter()
+    def dt(value: datetime.datetime):
+        return value.strftime("%Y-%m-%d %H:%M")
+
+    @app.template_filter()
+    def td(v: datetime.timedelta):
+        seconds = v.total_seconds()
+        h = int(seconds // 3600)
+        m = int(seconds // 60 % 60)
+        s = int(seconds // 1 % 60)
+        return f"{h}:{m:02d}:{s:02d}"
+
     authenticator = Authenticator(config_accessor())
 
     route_start(app, repository, config_accessor())
@@ -68,9 +81,7 @@ def web_ui_main(
 
     app.register_blueprint(
         make_activity_blueprint(
-            repository,
-            tile_visit_accessor,
-            config_accessor(),
+            repository, tile_visit_accessor, config_accessor(), authenticator
         ),
         url_prefix="/activity",
     )

{geo_activity_playground-0.30.0 → geo_activity_playground-0.32.0}/geo_activity_playground/webui/heatmap/heatmap_controller.py

@@ -90,23 +90,25 @@ class HeatmapController:
             tile_counts = np.zeros(tile_pixels, dtype=np.int32)
         tile_count_cache_path.parent.mkdir(parents=True, exist_ok=True)
         activity_ids = self.activities_per_tile[z].get((x, y), set())
-        if activity_ids:
+        activity_ids_kind = set()
+        for activity_id in activity_ids:
+            activity = self._repository.get_activity_by_id(activity_id)
+            if activity["kind"] == kind:
+                activity_ids_kind.add(activity_id)
+        if activity_ids_kind:
             with work_tracker(
                 tile_count_cache_path.with_suffix(".json")
             ) as parsed_activities:
-                if parsed_activities - activity_ids:
+                if parsed_activities - activity_ids_kind:
                     logger.warning(
                         f"Resetting heatmap cache for {kind=}/{x=}/{y=}/{z=} because activities have been removed."
                     )
                     tile_counts = np.zeros(tile_pixels, dtype=np.int32)
                     parsed_activities.clear()
-                for activity_id in activity_ids:
+                for activity_id in activity_ids_kind:
                     if activity_id in parsed_activities:
                         continue
                     parsed_activities.add(activity_id)
-                    activity = self._repository.get_activity_by_id(activity_id)
-                    if activity["kind"] != kind:
-                        continue
                     time_series = self._repository.get_time_series(activity_id)
                     for _, group in time_series.groupby("segment_id"):
                         xy_pixels = (

{geo_activity_playground-0.30.0 → geo_activity_playground-0.32.0}/geo_activity_playground/webui/search/templates/search/index.html.j2

@@ -78,10 +78,10 @@
                 {% for index, activity in activities %}
                 <tr>
                     <td><a href="{{ url_for('activity.show', id=activity['id']) }}">{{ activity['name'] }}</a></td>
-                    <td>{{ activity['start'] }}</td>
+                    <td>{{ activity['start']|dt }}</td>
                     <td>{{ activity['kind'] }}</td>
                     <td>{{ '%.1f' % activity["distance_km"] }} km</td>
-                    <td>{{ activity.elapsed_time }}</td>
+                    <td>{{ activity.elapsed_time|td }}</td>
                 </tr>
                 {% endfor %}
             </tbody>

{geo_activity_playground-0.30.0 → geo_activity_playground-0.32.0}/geo_activity_playground/webui/summary/controller.py

@@ -21,7 +21,7 @@ class SummaryController:
     def render(self) -> dict:
         kind_scale = make_kind_scale(self._repository.meta, self._config)
         df = embellished_activities(self._repository.meta)
-        df = df.loc[df["consider_for_achievements"]]
+        # df = df.loc[df["consider_for_achievements"]]
 
         year_kind_total = (
             df[["year", "kind", "distance_km", "hours"]]

{geo_activity_playground-0.30.0 → geo_activity_playground-0.32.0}/geo_activity_playground/webui/summary/templates/summary/index.html.j2

@@ -123,7 +123,7 @@
                 </p>
                 <p class="card-text"><small class="text-body-secondary"></small>{{ activity.kind }} with {{
                     (activity.distance_km)|round(1) }} km in {{
-                    activity.elapsed_time }} on {{ activity.start }}</small></p>
+                    activity.elapsed_time|td }} on {{ activity.start|dt }}</small></p>
             </div>
         </div>
     </div>

{geo_activity_playground-0.30.0 → geo_activity_playground-0.32.0}/geo_activity_playground/webui/templates/home.html.j2

@@ -49,8 +49,8 @@
                     <h5 class="card-title">{{ elem.activity["name"] }}</h5>
                 </a>
                 <p class="card-text">{{ elem.activity.kind }} with {{ (elem.activity.distance_km)|round(1) }} km in {{
-                    elem.activity.elapsed_time }}</p>
-                <p class="card-text"><small class="text-body-secondary">{{ elem.activity.start }}</small></p>
+                    elem.activity.elapsed_time|td }}</p>
+                <p class="card-text"><small class="text-body-secondary">{{ elem.activity.start|dt }}</small></p>
             </div>
         </div>
     </div>

{geo_activity_playground-0.30.0 → geo_activity_playground-0.32.0}/geo_activity_playground/webui/upload/controller.py

@@ -102,8 +102,7 @@ def scan_for_activities(
 ) -> None:
     if pathlib.Path("Activities").exists():
         import_from_directory(
-            config.metadata_extraction_regexes,
-            config.num_processes,
+            config.metadata_extraction_regexes, config.num_processes, config
         )
     if pathlib.Path("Strava Export").exists():
         import_from_strava_checkout()

{geo_activity_playground-0.30.0 → geo_activity_playground-0.32.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "geo-activity-playground"
-version = "0.30.0"
+version = "0.32.0"
 description = "Analysis of geo data activities like rides, runs or hikes."
 authors = ["Martin Ueding <mu@martin-ueding.de>"]
 license = "MIT"

geo_activity_playground-0.30.0/geo_activity_playground/webui/activity/blueprint.py

@@ -1,57 +0,0 @@
-import urllib.parse
-from collections.abc import Collection
-
-from flask import Blueprint
-from flask import render_template
-from flask import Response
-
-from ...core.activities import ActivityRepository
-from ...explorer.tile_visits import TileVisitAccessor
-from .controller import ActivityController
-from geo_activity_playground.core.config import Config
-from geo_activity_playground.core.privacy_zones import PrivacyZone
-
-
-def make_activity_blueprint(
-    repository: ActivityRepository,
-    tile_visit_accessor: TileVisitAccessor,
-    config: Config,
-) -> Blueprint:
-    blueprint = Blueprint("activity", __name__, template_folder="templates")
-
-    activity_controller = ActivityController(repository, tile_visit_accessor, config)
-
-    @blueprint.route("/all")
-    def all():
-        return render_template(
-            "activity/lines.html.j2", **activity_controller.render_all()
-        )
-
-    @blueprint.route("/<id>")
-    def show(id: str):
-        return render_template(
-            "activity/show.html.j2", **activity_controller.render_activity(int(id))
-        )
-
-    @blueprint.route("/<id>/sharepic.png")
-    def sharepic(id: str):
-        return Response(
-            activity_controller.render_sharepic(int(id)),
-            mimetype="image/png",
-        )
-
-    @blueprint.route("/day/<year>/<month>/<day>")
-    def day(year: str, month: str, day: str):
-        return render_template(
-            "activity/day.html.j2",
-            **activity_controller.render_day(int(year), int(month), int(day))
-        )
-
-    @blueprint.route("/name/<name>")
-    def name(name: str):
-        return render_template(
-            "activity/name.html.j2",
-            **activity_controller.render_name(urllib.parse.unquote(name))
-        )
-
-    return blueprint