geo-activity-playground 0.40.1__py3-none-any.whl → 0.42.0__py3-none-any.whl

geo_activity_playground/webui/blueprints/activity_blueprint.py

@@ -21,14 +21,15 @@ from PIL import Image
 from PIL import ImageDraw
 
 from ...core.activities import ActivityRepository
+from ...core.activities import make_color_bar
 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.datamodel import Tag
 from ...core.enrichment import update_via_time_series
 from ...core.heart_rate import HeartRateZoneComputer
 from ...core.privacy_zones import PrivacyZone
@@ -41,6 +42,8 @@ from ...explorer.grid_file import make_grid_points
 from ...explorer.tile_visits import TileVisitAccessor
 from ..authenticator import Authenticator
 from ..authenticator import needs_authentication
+from ..columns import column_elevation
+from ..columns import column_speed
 
 logger = logging.getLogger(__name__)
 
@@ -69,14 +72,14 @@ def make_activity_blueprint(
                                 )
                             ]
                             for _, group in repository.get_time_series(
-                                activity["id"]
+                                activity.id
                             ).groupby("segment_id")
                         ]
                     ),
                     properties={
                         "color": matplotlib.colors.to_hex(cmap(i % 8)),
-                        "activity_name": activity["name"],
-                        "activity_id": str(activity["id"]),
+                        "activity_name": activity.name,
+                        "activity_id": str(activity.id),
                     },
                 )
                 for i, activity in enumerate(repository.iter_activities())
@@ -97,7 +100,7 @@ def make_activity_blueprint(
 
         meta = repository.meta
         similar_activities = meta.loc[
-            (meta.name == activity["name"]) & (meta.id != activity["id"])
+            (meta.name == activity.name) & (meta.id != activity.id)
         ]
         similar_activities = [row for _, row in similar_activities.iterrows()]
         similar_activities.reverse()
@@ -105,7 +108,7 @@ def make_activity_blueprint(
         new_tiles = {
             zoom: sum(
                 tile_visit_accessor.tile_state["tile_history"][zoom]["activity_id"]
-                == activity["id"]
+                == activity.id
             )
             for zoom in sorted(config.explorer_zoom_levels)
         }
@@ -115,7 +118,7 @@ def make_activity_blueprint(
         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"]
+                == activity.id
             ]
             if len(new_tiles):
                 points = make_grid_points(
@@ -128,19 +131,34 @@ def make_activity_blueprint(
                 new_tiles_geojson[zoom] = make_grid_file_geojson(points)
             new_tiles_per_zoom[zoom] = len(new_tiles)
 
+        line_color_columns_avail = dict(
+            [(column.name, column) for column in [column_speed, column_elevation]]
+        )
+        line_color_column = (
+            request.args.get("line_color_column")
+            or next(iter(line_color_columns_avail.values())).name
+        )
+
         context = {
             "activity": activity,
             "line_json": line_json,
             "distance_time_plot": distance_time_plot(time_series),
-            "color_line_geojson": make_geojson_color_line(time_series),
+            "color_line_geojson": make_geojson_color_line(
+                time_series, line_color_column
+            ),
             "speed_time_plot": speed_time_plot(time_series),
             "speed_distribution_plot": speed_distribution_plot(time_series),
             "similar_activites": similar_activities,
-            "speed_color_bar": make_speed_color_bar(time_series),
-            "date": activity["start"].date(),
-            "time": activity["start"].time(),
+            "line_color_bar": make_color_bar(
+                time_series[line_color_column],
+                line_color_columns_avail[line_color_column].format,
+            ),
+            "date": activity.start.date(),
+            "time": activity.start.time(),
             "new_tiles": new_tiles_per_zoom,
             "new_tiles_geojson": new_tiles_geojson,
+            "line_color_column": line_color_column,
+            "line_color_columns_avail": line_color_columns_avail,
         }
         if (
             heart_zones := _extract_heart_rate_zones(
@@ -301,6 +319,7 @@ def make_activity_blueprint(
             abort(404)
         equipments = DB.session.scalars(sqlalchemy.select(Equipment)).all()
         kinds = DB.session.scalars(sqlalchemy.select(Kind)).all()
+        tags = DB.session.scalars(sqlalchemy.select(Tag)).all()
 
         if request.method == "POST":
             activity.name = request.form.get("name")
@@ -309,13 +328,18 @@ def make_activity_blueprint(
             if form_equipment == "null":
                 activity.equipment = None
             else:
-                activity.equipment = DB.session.get(Equipment, int(form_equipment))
+                activity.equipment = DB.session.get_one(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))
+                activity.kind = DB.session.get_one(Kind, int(form_kind))
+
+            form_tags = request.form.getlist("tag")
+            activity.tags = [
+                DB.session.get_one(Tag, int(tag_id_str)) for tag_id_str in form_tags
+            ]
 
             DB.session.commit()
             return redirect(url_for(".show", id=activity.id))
@@ -325,6 +349,7 @@ def make_activity_blueprint(
             activity=activity,
             kinds=kinds,
             equipments=equipments,
+            tags=tags,
         )
 
     @blueprint.route("/trim/<id>", methods=["GET", "POST"])

geo_activity_playground/webui/blueprints/bubble_chart_blueprint.py

@@ -3,6 +3,10 @@ import pandas as pd
 from flask import Blueprint
 from flask import render_template
 
+from ..columns import column_distance
+from ..columns import column_elevation_gain
+from ..columns import ColumnDescription
+
 
 def make_bubble_chart_blueprint(repository) -> Blueprint:
     blueprint = Blueprint("bubble_chart", __name__, template_folder="templates")
@@ -19,11 +23,16 @@ def make_bubble_chart_blueprint(repository) -> Blueprint:
 
         # Prepare the bubble chart data
         bubble_data = activities[
-            ["start", "distance_km", "kind", "activity_id"]
+            [
+                "start",
+                "kind",
+                "activity_id",
+                column_distance.name,
+                column_elevation_gain.name,
+            ]
         ].rename(
             columns={
                 "start": "date",
-                "distance_km": "distance",
                 "kind": "activity",
                 "activity_id": "id",
             }
@@ -33,29 +42,45 @@ def make_bubble_chart_blueprint(repository) -> Blueprint:
             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_distance=_make_bubble_chart(bubble_data, column_distance),
+            bubble_chart_elevation_gain=_make_bubble_chart(
+                bubble_data, column_elevation_gain
+            ),
         )
 
-        return render_template("bubble_chart/index.html.j2", bubble_chart=bubble_chart)
-
     return blueprint
+
+
+def _make_bubble_chart(bubble_data, column: ColumnDescription):
+    return (
+        alt.Chart(bubble_data, title=f"{column.display_name} per Day (Bubble Chart)")
+        .mark_circle()
+        .encode(
+            x=alt.X("date:T", title="Date"),
+            y=alt.Y(
+                f"{column.name}:Q",
+                title=f"{column.display_name} ({column.unit})",
+            ),
+            size=alt.Size(
+                f"{column.name}:Q",
+                scale=alt.Scale(range=[10, 300]),
+                title=f"{column.display_name}",
+            ),
+            color=alt.Color("activity:N", title="Activity"),
+            tooltip=[
+                alt.Tooltip("date:T", title="Date"),
+                alt.Tooltip(
+                    f"{column.name}:Q",
+                    title=f"{column.display_name} ({column.unit})",
+                    format=column.format,
+                ),
+                alt.Tooltip("activity:N", title="Activity"),
+                alt.Tooltip("activity_url:N", title="Activity Link"),
+            ],
+        )
+        .properties(height=800, width=1200)
+        .interactive()
+        .to_json(format="vega")
+    )

geo_activity_playground/webui/blueprints/calendar_blueprint.py

@@ -1,10 +1,14 @@
 import collections
 import datetime
 
+import pandas as pd
+import sqlalchemy
 from flask import Blueprint
 from flask import render_template
 
 from ...core.activities import ActivityRepository
+from ...core.datamodel import Activity
+from ...core.datamodel import DB
 
 
 def make_calendar_blueprint(repository: ActivityRepository) -> Blueprint:
@@ -12,9 +16,14 @@ def make_calendar_blueprint(repository: ActivityRepository) -> Blueprint:
 
     @blueprint.route("/")
     def index():
-        meta = repository.meta
+        data = DB.session.execute(
+            sqlalchemy.select(Activity.start, Activity.distance_km)
+        ).all()
+        df = pd.DataFrame(data)
+        df["year"] = df["start"].dt.year
+        df["month"] = df["start"].dt.month
 
-        monthly_distance = meta.groupby(
+        monthly_distance = df.groupby(
             ["year", "month"],
         ).apply(lambda group: sum(group["distance_km"]), include_groups=False)
         monthly_distance.name = "total_distance_km"
@@ -24,7 +33,7 @@ def make_calendar_blueprint(repository: ActivityRepository) -> Blueprint:
             .fillna(0.0)
         )
 
-        yearly_distance = meta.groupby(["year"]).apply(
+        yearly_distance = df.groupby(["year"]).apply(
             lambda group: sum(group["distance_km"]), include_groups=False
         )
         yearly_distance.name = "total_distance_km"
@@ -34,7 +43,6 @@ def make_calendar_blueprint(repository: ActivityRepository) -> Blueprint:
         }
 
         context = {
-            "num_activities": len(repository),
             "monthly_distances": monthly_pivot,
             "yearly_distances": yearly_distances,
         }

geo_activity_playground/webui/blueprints/eddington_blueprints.py

@@ -0,0 +1,253 @@
+import datetime
+from math import ceil
+
+import altair as alt
+import numpy as np
+import pandas as pd
+from flask import Blueprint
+from flask import render_template
+from flask import Request
+from flask import request
+
+from ...core.activities import ActivityRepository
+from ...core.meta_search import apply_search_query
+from ..columns import column_distance
+from ..columns import column_elevation_gain
+from ..columns import ColumnDescription
+from ..search_util import search_query_from_form
+from ..search_util import SearchQueryHistory
+
+
+def register_eddington_blueprint(
+    repository: ActivityRepository, search_query_history: SearchQueryHistory
+) -> Blueprint:
+    blueprint = Blueprint("eddington", __name__, template_folder="templates")
+
+    @blueprint.route("/")
+    def distance():
+        return _render_eddington_template(
+            repository, request, search_query_history, "distance", column_distance, [1]
+        )
+
+    @blueprint.route("/elevation_gain")
+    def elevation_gain():
+        return _render_eddington_template(
+            repository,
+            request,
+            search_query_history,
+            "elevation_gain",
+            column_elevation_gain,
+            [20, 10, 1],
+        )
+
+    return blueprint
+
+
+def _render_eddington_template(
+    repository: ActivityRepository,
+    request: Request,
+    search_query_history: SearchQueryHistory,
+    template_name,
+    column: ColumnDescription,
+    divisor_values_avail: list[int],
+) -> str:
+
+    column_name = column.name
+    display_name = column.display_name
+    divisor = int(request.args.get("eddington_divisor") or divisor_values_avail[0])
+
+    query = search_query_from_form(request.args)
+    search_query_history.register_query(query)
+    activities = (
+        apply_search_query(repository.meta, query)
+        .dropna(subset=["start", column_name])
+        .copy()
+    )
+
+    activities["year"] = [start.year for start in activities["start"]]
+    activities["date"] = [start.date() for start in activities["start"]]
+    activities["isoyear"] = [start.isocalendar().year for start in activities["start"]]
+    activities["isoweek"] = [start.isocalendar().week for start in activities["start"]]
+
+    en_per_day, eddington_df_per_day = _get_values_per_group(
+        activities.groupby("date"), column_name, divisor
+    )
+    en_per_week, eddington_df_per_week = _get_values_per_group(
+        activities.groupby(["isoyear", "isoweek"]), column_name, divisor
+    )
+
+    return render_template(
+        f"eddington/{template_name}.html.j2",
+        eddington_number=en_per_day,
+        logarithmic_plot=_make_eddington_plot(
+            eddington_df_per_day, en_per_day, "Days", column_name, display_name, divisor
+        ),
+        eddington_per_week=en_per_week,
+        eddington_per_week_plot=_make_eddington_plot(
+            eddington_df_per_week,
+            en_per_week,
+            "Weeks",
+            column_name,
+            display_name,
+            divisor,
+        ),
+        eddington_table=eddington_df_per_day.loc[
+            (eddington_df_per_day[column_name] > en_per_day)
+            & (eddington_df_per_day[column_name] <= en_per_day + 10 * divisor)
+            & (eddington_df_per_day[column_name] % divisor == 0)
+        ].to_dict(orient="records"),
+        eddington_table_weeks=eddington_df_per_week.loc[
+            (eddington_df_per_week[column_name] > en_per_week)
+            & (eddington_df_per_week[column_name] <= en_per_week + 10 * divisor)
+            & (eddington_df_per_week[column_name] % divisor == 0)
+        ].to_dict(orient="records"),
+        query=query.to_jinja(),
+        yearly_eddington=_get_yearly_eddington(activities, column_name, divisor),
+        eddington_number_history_plot=_get_eddington_number_history(
+            activities, column_name, divisor
+        ),
+        eddington_divisor=divisor,
+        divisor_values_avail=divisor_values_avail,
+    )
+
+
+def _get_values_per_group(grouped, columnName, divisor) -> tuple[int, pd.DataFrame]:
+    sum_per_group = grouped.apply(
+        lambda group: int(sum(group[columnName])), include_groups=False
+    )
+    counts = dict(zip(*np.unique(sorted(sum_per_group), return_counts=True)))
+    eddington = pd.DataFrame(
+        {columnName: d, "count": counts.get(d, 0)}
+        for d in range(max(counts.keys()) + 1)
+    )
+    eddington["total"] = eddington["count"][::-1].cumsum()[::-1]
+    eddington[f"{columnName}_div"] = eddington[columnName] // divisor
+    en = (
+        eddington.loc[eddington["total"] >= eddington[f"{columnName}_div"]][
+            "total"
+        ].iloc[-1]
+        * divisor
+    )
+    eddington["missing"] = eddington[f"{columnName}_div"] - eddington["total"]
+
+    return en, eddington
+
+
+def _make_eddington_plot(
+    eddington_df: pd.DataFrame,
+    en: int,
+    interval: str,
+    column_name: str,
+    display_name: str,
+    divisor: int,
+) -> dict:
+    x = list(range(1, max(eddington_df[column_name]) + 1))
+    y = [v / divisor for v in x]
+    return (
+        (
+            (
+                alt.Chart(
+                    eddington_df,
+                    height=500,
+                    width=800,
+                    title=f"{display_name} Eddington Number {en}",
+                )
+                .mark_area(interpolate="step")
+                .encode(
+                    alt.X(
+                        column_name,
+                        scale=alt.Scale(domainMin=0, domainMax=en * 3),
+                        title=display_name,
+                    ),
+                    alt.Y(
+                        "total",
+                        scale=alt.Scale(domainMax=en / divisor * 1.5),
+                        title=f"{interval} exceeding {display_name}",
+                    ),
+                    [
+                        alt.Tooltip(column_name, title=display_name),
+                        alt.Tooltip(
+                            "total", title=f"{interval} exceeding {display_name}"
+                        ),
+                        alt.Tooltip("missing", title=f"{interval} missing for next"),
+                    ],
+                )
+            )
+            + (
+                alt.Chart(pd.DataFrame({column_name: x, "total": y}))
+                .mark_line(color="red")
+                .encode(alt.X(column_name), alt.Y("total"))
+            )
+        )
+        .interactive(bind_x=True, bind_y=True)
+        .to_json(format="vega")
+    )
+
+
+def _get_eddington_number(elevation_gains: pd.Series, divisor: int) -> int:
+    if len(elevation_gains) == 1:
+        if elevation_gains.iloc[0] >= 1:
+            return 1
+        else:
+            0
+
+    sorted_elevation_gains = sorted(elevation_gains, reverse=True)
+
+    for number_of_days, elevation_gain in enumerate(sorted_elevation_gains, 1):
+        if elevation_gain / divisor < number_of_days:
+            return (number_of_days - 1) * divisor
+
+
+def _get_yearly_eddington(
+    meta: pd.DataFrame, columnName: str, divisor: int
+) -> dict[int, int]:
+    meta = meta.dropna(subset=["start", columnName]).copy()
+    meta["year"] = [start.year for start in meta["start"]]
+    meta["date"] = [start.date() for start in meta["start"]]
+
+    yearly_eddington = meta.groupby("year").apply(
+        lambda group: _get_eddington_number(
+            group.groupby("date").apply(
+                lambda group2: int(group2[columnName].sum()), include_groups=False
+            ),
+            divisor,
+        ),
+        include_groups=False,
+    )
+    return yearly_eddington.to_dict()
+
+
+def _get_eddington_number_history(
+    meta: pd.DataFrame, columnName: str, divisor: int
+) -> dict:
+
+    daily_elevation_gains = meta.groupby("date").apply(
+        lambda group2: int(group2[columnName].sum()), include_groups=False
+    )
+
+    eddington_number_history = {"date": [], "eddington_number": []}
+    top_days = []
+    for date, elevation_gain in daily_elevation_gains.items():
+        elevation_gain = elevation_gain / divisor
+        if len(top_days) == 0:
+            top_days.append(elevation_gain)
+        else:
+            if elevation_gain >= top_days[0]:
+                top_days.append(elevation_gain)
+                top_days.sort()
+        while top_days[0] < len(top_days):
+            top_days.pop(0)
+        eddington_number_history["date"].append(
+            datetime.datetime.combine(date, datetime.datetime.min.time())
+        )
+        eddington_number_history["eddington_number"].append(len(top_days) * divisor)
+    history = pd.DataFrame(eddington_number_history)
+
+    return (
+        alt.Chart(history)
+        .mark_line(interpolate="step-after")
+        .encode(
+            alt.X("date", title="Date"),
+            alt.Y("eddington_number", title="Eddington number"),
+        )
+    ).to_json(format="vega")

geo_activity_playground/webui/blueprints/entry_views.py

@@ -4,12 +4,18 @@ import datetime
 import altair as alt
 import flask
 import pandas as pd
+import sqlalchemy
 from flask import render_template
 from flask import Response
 
 from ...core.activities import ActivityRepository
 from ...core.activities import make_geojson_from_time_series
 from ...core.config import Config
+from ...core.datamodel import Activity
+from ...core.datamodel import DB
+from ..columns import column_distance
+from ..columns import column_elevation_gain
+from ..columns import ColumnDescription
 from ..plot_util import make_kind_scale
 
 
@@ -22,27 +28,32 @@ def register_entry_views(
 
         if len(repository):
             kind_scale = make_kind_scale(repository.meta, config)
-            context["distance_last_30_days_plot"] = _distance_last_30_days_meta_plot(
-                repository.meta, kind_scale
+            context["distance_last_30_days_plot"] = _last_30_days_meta_plot(
+                repository.meta, kind_scale, column_distance
+            )
+            context["elevation_gain_last_30_days_plot"] = _last_30_days_meta_plot(
+                repository.meta, kind_scale, column_elevation_gain
             )
 
-        meta = repository.meta.copy()
-        meta["date"] = meta["start"].dt.date
-
-        context["latest_activities"] = collections.defaultdict(list)
-        for date, activity_meta in list(meta.groupby("date"))[:-30:-1]:
-            for index, activity in activity_meta.iterrows():
-                time_series = repository.get_time_series(activity["id"])
-                context["latest_activities"][date].append(
+            context["latest_activities"] = collections.defaultdict(list)
+            for activity in DB.session.scalars(
+                sqlalchemy.select(Activity).order_by(Activity.start.desc()).limit(100)
+            ):
+                context["latest_activities"][activity.start.date()].append(
                     {
                         "activity": activity,
-                        "line_geojson": make_geojson_from_time_series(time_series),
+                        "line_geojson": make_geojson_from_time_series(
+                            activity.time_series
+                        ),
                     }
                 )
+
         return render_template("home.html.j2", **context)
 
 
-def _distance_last_30_days_meta_plot(meta: pd.DataFrame, kind_scale: alt.Scale) -> str:
+def _last_30_days_meta_plot(
+    meta: pd.DataFrame, kind_scale: alt.Scale, column: ColumnDescription
+) -> str:
     before_30_days = pd.to_datetime(
         datetime.datetime.now() - datetime.timedelta(days=31)
     )
@@ -51,17 +62,21 @@ def _distance_last_30_days_meta_plot(meta: pd.DataFrame, kind_scale: alt.Scale)
             meta.loc[meta["start"] > before_30_days],
             width=700,
             height=200,
-            title="Distance per day",
+            title=f"{column.display_name} per day",
         )
         .mark_bar()
         .encode(
             alt.X("yearmonthdate(start)", title="Date"),
-            alt.Y("sum(distance_km)", title="Distance / km"),
+            alt.Y(f"sum({column.name})", title=f"{column.name} / {column.unit}"),
             alt.Color("kind", scale=kind_scale, title="Kind"),
             [
                 alt.Tooltip("yearmonthdate(start)", title="Date"),
                 alt.Tooltip("kind", title="Kind"),
-                alt.Tooltip("sum(distance_km)", format=".1f", title="Distance / km"),
+                alt.Tooltip(
+                    f"sum({column.name})",
+                    format=column.format,
+                    title=f"{column.display_name} / {column.unit}",
+                ),
             ],
         )
         .to_json(format="vega")