geo-activity-playground 0.38.2__py3-none-any.whl → 0.39.0__py3-none-any.whl

geo_activity_playground/webui/{activity/controller.py → blueprints/activity_blueprint.py}

@@ -9,47 +9,93 @@ import geojson
 import matplotlib
 import numpy as np
 import pandas as pd
+import sqlalchemy
+from flask import abort
+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 PIL import Image
 from PIL import ImageDraw
 
-from geo_activity_playground.core.activities import ActivityMeta
-from geo_activity_playground.core.activities import ActivityRepository
-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.config import Config
-from geo_activity_playground.core.heart_rate import HeartRateZoneComputer
-from geo_activity_playground.core.privacy_zones import PrivacyZone
-from geo_activity_playground.core.raster_map import map_image_from_tile_bounds
-from geo_activity_playground.core.raster_map import OSM_MAX_ZOOM
-from geo_activity_playground.core.raster_map import OSM_TILE_SIZE
-from geo_activity_playground.core.raster_map import tile_bounds_around_center
-from geo_activity_playground.explorer.grid_file import make_grid_file_geojson
-from geo_activity_playground.explorer.grid_file import make_grid_points
-from geo_activity_playground.explorer.tile_visits import TileVisitAccessor
+from ...core.activities import ActivityRepository
+from ...core.activities import make_geojson_color_line
+from ...core.activities import make_geojson_from_time_series
+from ...core.activities import make_speed_color_bar
+from ...core.config import Config
+from ...core.datamodel import Activity
+from ...core.datamodel import DB
+from ...core.datamodel import Equipment
+from ...core.datamodel import Kind
+from ...core.enrichment import update_via_time_series
+from ...core.heart_rate import HeartRateZoneComputer
+from ...core.privacy_zones import PrivacyZone
+from ...core.raster_map import map_image_from_tile_bounds
+from ...core.raster_map import OSM_MAX_ZOOM
+from ...core.raster_map import OSM_TILE_SIZE
+from ...core.raster_map import tile_bounds_around_center
+from ...explorer.grid_file import make_grid_file_geojson
+from ...explorer.grid_file import make_grid_points
+from ...explorer.tile_visits import TileVisitAccessor
+from ..authenticator import Authenticator
+from ..authenticator import needs_authentication
 
 logger = logging.getLogger(__name__)
 
 
-class ActivityController:
-    def __init__(
-        self,
-        repository: ActivityRepository,
-        tile_visit_accessor: TileVisitAccessor,
-        config: Config,
-    ) -> None:
-        self._repository = repository
-        self._tile_visit_accessor = tile_visit_accessor
-        self._config = config
-        self._heart_rate_zone_computer = HeartRateZoneComputer(config)
+def make_activity_blueprint(
+    repository: ActivityRepository,
+    authenticator: Authenticator,
+    tile_visit_accessor: TileVisitAccessor,
+    config: Config,
+    heart_rate_zone_computer: HeartRateZoneComputer,
+) -> Blueprint:
+    blueprint = Blueprint("activity", __name__, template_folder="templates")
 
-    def render_activity(self, id: int) -> dict:
-        activity = self._repository.get_activity_by_id(id)
+    @blueprint.route("/all")
+    def all():
+        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 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(repository.iter_activities())
+            ]
+        )
+
+        context = {
+            "geojson": geojson.dumps(fc),
+        }
+        return render_template("activity/lines.html.j2", **context)
 
-        time_series = self._repository.get_time_series(id)
+    @blueprint.route("/<int:id>")
+    def show(id: str):
+        activity = repository.get_activity_by_id(id)
+
+        time_series = repository.get_time_series(id)
         line_json = make_geojson_from_time_series(time_series)
 
-        meta = self._repository.meta
+        meta = repository.meta
         similar_activities = meta.loc[
             (meta.name == activity["name"]) & (meta.id != activity["id"])
         ]
@@ -58,21 +104,17 @@ class ActivityController:
 
         new_tiles = {
             zoom: sum(
-                self._tile_visit_accessor.tile_state["tile_history"][zoom][
-                    "activity_id"
-                ]
+                tile_visit_accessor.tile_state["tile_history"][zoom]["activity_id"]
                 == activity["id"]
             )
-            for zoom in sorted(self._config.explorer_zoom_levels)
+            for zoom in sorted(config.explorer_zoom_levels)
         }
 
         new_tiles_geojson = {}
         new_tiles_per_zoom = {}
-        for zoom in sorted(self._config.explorer_zoom_levels):
-            new_tiles = self._tile_visit_accessor.tile_state["tile_history"][zoom].loc[
-                self._tile_visit_accessor.tile_state["tile_history"][zoom][
-                    "activity_id"
-                ]
+        for zoom in sorted(config.explorer_zoom_levels):
+            new_tiles = tile_visit_accessor.tile_state["tile_history"][zoom].loc[
+                tile_visit_accessor.tile_state["tile_history"][zoom]["activity_id"]
                 == activity["id"]
             ]
             if len(new_tiles):
@@ -86,7 +128,7 @@ class ActivityController:
                 new_tiles_geojson[zoom] = make_grid_file_geojson(points)
             new_tiles_per_zoom[zoom] = len(new_tiles)
 
-        result = {
+        context = {
             "activity": activity,
             "line_json": line_json,
             "distance_time_plot": distance_time_plot(time_series),
@@ -102,39 +144,45 @@ class ActivityController:
         }
         if (
             heart_zones := _extract_heart_rate_zones(
-                time_series, self._heart_rate_zone_computer
+                time_series, heart_rate_zone_computer
             )
         ) is not None:
-            result["heart_zones_plot"] = heart_rate_zone_plot(heart_zones)
+            context["heart_zones_plot"] = heart_rate_zone_plot(heart_zones)
         if "altitude" in time_series.columns:
-            result["altitude_time_plot"] = altitude_time_plot(time_series)
+            context["altitude_time_plot"] = altitude_time_plot(time_series)
         if "elevation_gain_cum" in time_series.columns:
-            result["elevation_gain_cum_plot"] = elevation_gain_cum_plot(time_series)
+            context["elevation_gain_cum_plot"] = elevation_gain_cum_plot(time_series)
         if "heartrate" in time_series.columns:
-            result["heartrate_time_plot"] = heart_rate_time_plot(time_series)
+            context["heartrate_time_plot"] = heart_rate_time_plot(time_series)
         if "cadence" in time_series.columns:
-            result["cadence_time_plot"] = cadence_time_plot(time_series)
-        return result
+            context["cadence_time_plot"] = cadence_time_plot(time_series)
+
+        return render_template("activity/show.html.j2", **context)
 
-    def render_sharepic(self, id: int) -> bytes:
-        activity = self._repository.get_activity_by_id(id)
-        time_series = self._repository.get_time_series(id)
-        for coordinates in self._config.privacy_zones.values():
+    @blueprint.route("/<int:id>/sharepic.png")
+    def sharepic(id: int):
+        activity = repository.get_activity_by_id(id)
+        time_series = repository.get_time_series(id)
+        for coordinates in config.privacy_zones.values():
             privacy_zone = PrivacyZone(coordinates)
             time_series = privacy_zone.filter_time_series(time_series)
         if len(time_series) == 0:
-            time_series = self._repository.get_time_series(id)
-        return make_sharepic(
-            activity, time_series, self._config.sharepic_suppressed_fields, self._config
+            time_series = repository.get_time_series(id)
+        return Response(
+            make_sharepic(
+                activity, time_series, config.sharepic_suppressed_fields, config
+            ),
+            mimetype="image/png",
         )
 
-    def render_day(self, year: int, month: int, day: int) -> dict:
-        meta = self._repository.meta
+    @blueprint.route("/day/<int:year>/<int:month>/<int:day>")
+    def day(year: int, month: int, day: int):
+        meta = 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)
+            repository.get_time_series(activity_id)
             for activity_id in activities_that_day["id"]
         ]
 
@@ -163,7 +211,7 @@ class ActivityController:
         for i, activity_record in enumerate(activities_list):
             activity_record["color"] = matplotlib.colors.to_hex(cmap(i % 8))
 
-        return {
+        context = {
             "activities": activities_list,
             "geojson": geojson.dumps(fc),
             "date": datetime.date(year, month, day).isoformat(),
@@ -173,59 +221,36 @@ class ActivityController:
             "month": month,
             "year": year,
         }
+        return render_template(
+            "activity/day.html.j2",
+            **context,
+        )
 
-    def render_day_sharepic(self, year: int, month: int, day: int) -> bytes:
-        meta = self._repository.meta
+    @blueprint.route("/day-sharepic/<int:year>/<int:month>/<int:day>/sharepic.png")
+    def day_sharepic(year: int, month: int, day: int):
+        meta = 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)
+            repository.get_time_series(activity_id)
             for activity_id in activities_that_day["id"]
         ]
         assert len(activities_that_day) > 0
         assert len(time_series) > 0
-        return (make_day_sharepic(activities_that_day, time_series, self._config),)
-
-    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 Response(
+            make_day_sharepic(activities_that_day, time_series, config),
+            mimetype="image/png",
         )
 
-        return {
-            "geojson": geojson.dumps(fc),
-        }
-
-    def render_name(self, name: str) -> dict:
-        meta = self._repository.meta
+    @blueprint.route("/name/<name>")
+    def name(name: str):
+        meta = repository.meta
         selection = meta["name"] == name
         activities_with_name = meta.loc[selection]
 
         time_series = [
-            self._repository.get_time_series(activity_id)
+            repository.get_time_series(activity_id)
             for activity_id in activities_with_name["id"]
         ]
 
@@ -254,7 +279,7 @@ class ActivityController:
         for i, activity_record in enumerate(activities_list):
             activity_record["color"] = matplotlib.colors.to_hex(cmap(i % 8))
 
-        return {
+        context = {
             "activities": activities_list,
             "geojson": geojson.dumps(fc),
             "name": name,
@@ -263,6 +288,115 @@ class ActivityController:
             "distance_plot": name_distance_plot(activities_with_name),
             "minutes_plot": name_minutes_plot(activities_with_name),
         }
+        return render_template(
+            "activity/name.html.j2",
+            **context,
+        )
+
+    @blueprint.route("/edit/<id>", methods=["GET", "POST"])
+    @needs_authentication(authenticator)
+    def edit(id: str):
+        activity = DB.session.get(Activity, int(id))
+        if activity is None:
+            abort(404)
+        equipments = DB.session.scalars(sqlalchemy.select(Equipment)).all()
+        kinds = DB.session.scalars(sqlalchemy.select(Kind)).all()
+
+        if request.method == "POST":
+            activity.name = request.form.get("name")
+
+            form_equipment = request.form.get("equipment")
+            if form_equipment == "null":
+                activity.equipment = None
+            else:
+                activity.equipment = DB.session.get(Equipment, int(form_equipment))
+
+            form_kind = request.form.get("kind")
+            if form_kind == "null":
+                activity.kind = None
+            else:
+                activity.kind = DB.session.get(Kind, int(form_kind))
+
+            DB.session.commit()
+            return redirect(url_for(".show", id=activity.id))
+
+        return render_template(
+            "activity/edit.html.j2",
+            activity=activity,
+            kinds=kinds,
+            equipments=equipments,
+        )
+
+    @blueprint.route("/trim/<id>", methods=["GET", "POST"])
+    @needs_authentication(authenticator)
+    def trim(id: str):
+        activity = DB.session.get(Activity, int(id))
+        if activity is None:
+            abort(404)
+
+        if request.method == "POST":
+            form_begin = request.form.get("begin")
+            form_end = request.form.get("end")
+
+            if form_begin:
+                activity.index_begin = int(form_begin)
+            if form_end:
+                activity.index_end = int(form_end)
+
+            update_via_time_series(activity, activity.time_series)
+
+            DB.session.commit()
+
+        cmap = matplotlib.colormaps["turbo"]
+        num_points = len(activity.time_series)
+        begin = activity.index_begin or 0
+        end = activity.index_end or num_points
+
+        fc = geojson.FeatureCollection(
+            features=[
+                geojson.Feature(
+                    geometry=geojson.LineString(
+                        [
+                            (lon, lat)
+                            for lat, lon in zip(group["latitude"], group["longitude"])
+                        ]
+                    )
+                )
+                for _, group in activity.raw_time_series.groupby("segment_id")
+            ]
+            + [
+                geojson.Feature(
+                    geometry=geojson.Point(
+                        (lon, lat),
+                    ),
+                    properties={
+                        "name": f"{index}",
+                        "markerType": "circle",
+                        "markerStyle": {
+                            "fillColor": matplotlib.colors.to_hex(
+                                cmap(1 - index / num_points)
+                            ),
+                            "fillOpacity": 0.5,
+                            "radius": 8,
+                            "color": "black" if begin <= index < end else "white",
+                            "opacity": 0.8,
+                            "weight": 2,
+                        },
+                    },
+                )
+                for _, group in activity.raw_time_series.groupby("segment_id")
+                for index, lat, lon in zip(
+                    group.index, group["latitude"], group["longitude"]
+                )
+            ]
+        )
+        return render_template(
+            "activity/trim.html.j2",
+            activity=activity,
+            color_line_geojson=geojson.dumps(fc),
+        )
+
+    return blueprint
 
 
 def speed_time_plot(time_series: pd.DataFrame) -> str:
@@ -482,7 +616,7 @@ def make_sharepic_base(time_series_list: list[pd.DataFrame], config: Config):
 
 
 def make_sharepic(
-    activity: ActivityMeta,
+    activity: Activity,
     time_series: pd.DataFrame,
     sharepic_suppressed_fields: list[str],
     config: Config,
@@ -497,17 +631,21 @@ def make_sharepic(
     )
 
     facts = {
-        "kind": f"{activity['kind']}",
-        "start": f"{activity['start'].date()}",
-        "equipment": f"{activity['equipment']}",
-        "distance_km": f"\n{activity['distance_km']:.1f} km",
-        "elapsed_time": re.sub(r"^0 days ", "", f"{activity['elapsed_time']}"),
+        "distance_km": f"\n{activity.distance_km:.1f} km",
     }
-
-    if activity.get("calories", 0) and not pd.isna(activity["calories"]):
-        facts["calories"] = f"{activity['calories']:.0f} kcal"
-    if activity.get("steps", 0) and not pd.isna(activity["steps"]):
-        facts["steps"] = f"{activity['steps']:.0f} steps"
+    if activity.start:
+        facts["start"] = f"{activity.start.date()}"
+    if activity.elapsed_time:
+        facts["elapsed_time"] = re.sub(r"^0 days ", "", f"{activity.elapsed_time}")
+    if activity.kind:
+        facts["kind"] = f"{activity.kind.name}"
+    if activity.equipment:
+        facts["equipment"] = f"{activity.equipment.name}"
+
+    if activity.calories:
+        facts["calories"] = f"{activity.calories} kcal"
+    if activity.steps:
+        facts["steps"] = f"{activity.steps} steps"
 
     facts = {
         key: value

geo_activity_playground/webui/{auth_blueprint.py → blueprints/auth_blueprint.py}

@@ -4,7 +4,7 @@ from flask import render_template
 from flask import request
 from flask import url_for
 
-from .authenticator import Authenticator
+from ..authenticator import Authenticator
 
 
 def make_auth_blueprint(authenticator: Authenticator) -> Blueprint:

geo_activity_playground/webui/blueprints/bubble_chart_blueprint.py

@@ -0,0 +1,61 @@
+import altair as alt
+import pandas as pd
+from flask import Blueprint
+from flask import render_template
+
+
+def make_bubble_chart_blueprint(repository) -> Blueprint:
+    blueprint = Blueprint("bubble_chart", __name__, template_folder="templates")
+
+    @blueprint.route("/", endpoint="index")
+    def bubble_chart():
+        activities = repository.meta
+
+        # Ensure 'activity_id' exists in the activities DataFrame
+        if "activity_id" not in activities.columns:
+            activities["activity_id"] = (
+                activities.index
+            )  # Use index as fallback if missing
+
+        # Prepare the bubble chart data
+        bubble_data = activities[
+            ["start", "distance_km", "kind", "activity_id"]
+        ].rename(
+            columns={
+                "start": "date",
+                "distance_km": "distance",
+                "kind": "activity",
+                "activity_id": "id",
+            }
+        )
+        bubble_data["date"] = pd.to_datetime(bubble_data["date"]).dt.date
+        bubble_data["activity_url"] = bubble_data["id"].apply(
+            lambda x: f"/activity/{x}"
+        )
+
+        # Create the bubble chart
+        bubble_chart = (
+            alt.Chart(bubble_data, title="Distance per Day (Bubble Chart)")
+            .mark_circle()
+            .encode(
+                x=alt.X("date:T", title="Date"),
+                y=alt.Y("distance:Q", title="Distance (km)"),
+                size=alt.Size(
+                    "distance:Q", scale=alt.Scale(range=[10, 300]), title="Distance"
+                ),
+                color=alt.Color("activity:N", title="Activity"),
+                tooltip=[
+                    alt.Tooltip("date:T", title="Date"),
+                    alt.Tooltip("distance:Q", title="Distance (km)", format=".1f"),
+                    alt.Tooltip("activity:N", title="Activity"),
+                    alt.Tooltip("activity_url:N", title="Activity Link"),
+                ],
+            )
+            .properties(height=800, width=1200)
+            .interactive()
+            .to_json(format="vega")
+        )
+
+        return render_template("bubble_chart/index.html.j2", bubble_chart=bubble_chart)
+
+    return blueprint

geo_activity_playground/webui/{calendar/controller.py → blueprints/calendar_blueprint.py}

@@ -1,18 +1,18 @@
 import collections
 import datetime
 
+from flask import Blueprint
+from flask import render_template
+
 from ...core.activities import ActivityRepository
 
 
-class CalendarController:
-    def __init__(self, repository: ActivityRepository) -> None:
-        self._repository = repository
+def make_calendar_blueprint(repository: ActivityRepository) -> Blueprint:
+    blueprint = Blueprint("calendar", __name__, template_folder="templates")
 
-    def render_overview(self) -> dict:
-        meta = self._repository.meta.copy()
-        meta["date"] = meta["start"].dt.date
-        meta["year"] = meta["start"].dt.year
-        meta["month"] = meta["start"].dt.month
+    @blueprint.route("/")
+    def index():
+        meta = repository.meta
 
         monthly_distance = meta.groupby(
             ["year", "month"],
@@ -33,20 +33,16 @@ class CalendarController:
             for index, row in yearly_distance.reset_index().iterrows()
         }
 
-        return {
-            "num_activities": len(self._repository.meta),
+        context = {
+            "num_activities": len(repository),
             "monthly_distances": monthly_pivot,
             "yearly_distances": yearly_distances,
         }
+        return render_template("calendar/index.html.j2", **context)
 
-    def render_month(self, year: int, month: int) -> dict:
-        meta = self._repository.meta.copy()
-        meta["date"] = meta["start"].dt.date
-        meta["year"] = meta["start"].dt.year
-        meta["month"] = meta["start"].dt.month
-        meta["day"] = meta["start"].dt.day
-        meta["day_of_week"] = meta["start"].dt.day_of_week
-        meta["isoweek"] = meta["start"].dt.isocalendar().week
+    @blueprint.route("/<int:year>/<int:month>")
+    def month(year: int, month: int):
+        meta = repository.meta
 
         filtered = meta.loc[
             (meta["year"] == year) & (meta["month"] == month)
@@ -72,9 +68,13 @@ class CalendarController:
                 }
             )
 
-        return {
+        context = {
             "year": year,
             "month": month,
             "weeks": weeks,
             "day_of_month": day_of_month,
         }
+
+        return render_template("calendar/month.html.j2", **context)
+
+    return blueprint

geo_activity_playground/webui/{eddington_blueprint.py → blueprints/eddington_blueprint.py}

@@ -7,13 +7,13 @@ from flask import Blueprint
 from flask import render_template
 from flask import request
 
-from geo_activity_playground.core.activities import ActivityRepository
-from geo_activity_playground.core.meta_search import apply_search_query
-from geo_activity_playground.webui.search_util import search_query_from_form
-from geo_activity_playground.webui.search_util import SearchQueryHistory
+from ...core.activities import ActivityRepository
+from ...core.meta_search import apply_search_query
+from ..search_util import search_query_from_form
+from ..search_util import SearchQueryHistory
 
 
-def make_eddington_blueprint(
+def register_eddington_blueprint(
     repository: ActivityRepository, search_query_history: SearchQueryHistory
 ) -> Blueprint:
     blueprint = Blueprint("eddington", __name__, template_folder="templates")