geo-activity-playground 0.45.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

geo_activity_playground/webui/blueprints/hall_of_fame_blueprint.py

@@ -0,0 +1,79 @@
+import collections
+
+import pandas as pd
+from flask import Blueprint
+from flask import render_template
+from flask import request
+
+from ...core.activities import ActivityRepository
+from ...core.activities import make_geojson_from_time_series
+from ...core.meta_search import apply_search_query
+from ..search_util import search_query_from_form
+from ..search_util import SearchQueryHistory
+
+
+def make_hall_of_fame_blueprint(
+    repository: ActivityRepository,
+    search_query_history: SearchQueryHistory,
+) -> Blueprint:
+    blueprint = Blueprint("hall_of_fame", __name__, template_folder="templates")
+
+    @blueprint.route("/")
+    def index() -> str:
+        query = search_query_from_form(request.args)
+        search_query_history.register_query(query)
+        activities = apply_search_query(repository.meta, query)
+        df = activities
+
+        nominations = nominate_activities(df)
+
+        return render_template(
+            "hall_of_fame/index.html.j2",
+            nominations=[
+                (
+                    repository.get_activity_by_id(activity_id),
+                    reasons,
+                    make_geojson_from_time_series(
+                        repository.get_time_series(activity_id)
+                    ),
+                )
+                for activity_id, reasons in nominations.items()
+            ],
+            query=query.to_jinja(),
+        )
+
+    return blueprint
+
+
+def nominate_activities(meta: pd.DataFrame) -> dict[int, list[str]]:
+    nominations: dict[int, list[str]] = collections.defaultdict(list)
+
+    _nominate_activities_inner(meta, "", nominations)
+
+    for kind, group in meta.groupby("kind"):
+        _nominate_activities_inner(group, f" for {kind}", nominations)
+    for equipment, group in meta.groupby("equipment"):
+        _nominate_activities_inner(group, f" with {equipment}", nominations)
+
+    return nominations
+
+
+def _nominate_activities_inner(
+    meta: pd.DataFrame, title_suffix: str, nominations: dict[int, list[str]]
+) -> None:
+    ratings = [
+        ("distance_km", "Greatest distance", "{:.1f} km"),
+        ("elapsed_time", "Longest elapsed time", "{}"),
+        ("average_speed_moving_kmh", "Highest average moving speed", "{:.1f} km/h"),
+        ("average_speed_elapsed_kmh", "Highest average elapsed speed", "{:.1f} km/h"),
+        ("calories", "Most calories burnt", "{:.0f}"),
+        ("steps", "Most steps", "{:.0f}"),
+        ("elevation_gain", "Largest elevation gain", "{:.0f} m"),
+    ]
+
+    for variable, title, format_str in ratings:
+        if variable in meta.columns and not pd.isna(meta[variable]).all():
+            i = meta[variable].idxmax()
+            value = meta.loc[i, variable]
+            format_applied = format_str.format(value)
+            nominations[i].append(f"{title}{title_suffix}: {format_applied}")

geo_activity_playground/webui/blueprints/plot_builder_blueprint.py

@@ -1,3 +1,5 @@
+import json
+
 import sqlalchemy
 from flask import Blueprint
 from flask import redirect
@@ -5,9 +7,12 @@ from flask import render_template
 from flask import request
 from flask import Response
 from flask import url_for
+from flask.typing import ResponseReturnValue
+from flask.typing import RouteCallable
 
 from ...core.activities import ActivityRepository
 from ...core.datamodel import DB
+from ...core.parametric_plot import GROUP_BY_VARIABLES
 from ...core.parametric_plot import make_parametric_plot
 from ...core.parametric_plot import MARKS
 from ...core.parametric_plot import PlotSpec
@@ -25,7 +30,7 @@ def make_plot_builder_blueprint(
     blueprint = Blueprint("plot_builder", __name__, template_folder="templates")
 
     @blueprint.route("/")
-    def index() -> Response:
+    def index() -> ResponseReturnValue:
         return render_template(
             "plot_builder/index.html.j2",
             specs=DB.session.scalars(sqlalchemy.select(PlotSpec)).all(),
@@ -33,7 +38,7 @@ def make_plot_builder_blueprint(
 
     @blueprint.route("/new")
     @needs_authentication(authenticator)
-    def new() -> Response:
+    def new() -> ResponseReturnValue:
         spec = PlotSpec(
             name="My New Plot",
             mark="bar",
@@ -45,23 +50,36 @@ def make_plot_builder_blueprint(
         DB.session.commit()
         return redirect(url_for(".edit", id=spec.id))
 
-    @blueprint.route("/edit/<int:id>")
+    @blueprint.route("/import-spec", methods=["GET", "POST"])
     @needs_authentication(authenticator)
-    def edit(id: int) -> Response:
-        spec = DB.session.get(PlotSpec, id)
-        if request.args:
-            spec.name = request.args["name"]
-            spec.mark = request.args["mark"]
-            spec.x = request.args["x"]
-            spec.y = request.args["y"]
-            spec.color = request.args["color"]
-            spec.shape = request.args["shape"]
-            spec.size = request.args["size"]
-            spec.size = request.args["size"]
-            spec.row = request.args["row"]
-            spec.column = request.args["column"]
-            spec.facet = request.args["facet"]
-            spec.opacity = request.args["opacity"]
+    def import_spec() -> ResponseReturnValue:
+        if request.form:
+            parameters = json.loads(request.form["spec_json"])
+            spec = PlotSpec(**parameters)
+            DB.session.add(spec)
+            DB.session.commit()
+            return redirect(url_for(".edit", id=spec.id))
+        else:
+            return render_template("plot_builder/import-spec.html.j2")
+
+    @blueprint.route("/edit/<int:id>", methods=["GET", "POST"])
+    @needs_authentication(authenticator)
+    def edit(id: int) -> ResponseReturnValue:
+        spec = DB.session.get_one(PlotSpec, id)
+        if request.form:
+            spec.name = request.form["name"]
+            spec.mark = request.form["mark"]
+            spec.x = request.form["x"]
+            spec.y = request.form["y"]
+            spec.color = request.form["color"]
+            spec.shape = request.form["shape"]
+            spec.size = request.form["size"]
+            spec.size = request.form["size"]
+            spec.row = request.form["row"]
+            spec.column = request.form["column"]
+            spec.facet = request.form["facet"]
+            spec.opacity = request.form["opacity"]
+            spec.group_by = request.form["group_by"]
         try:
             plot = make_parametric_plot(repository.meta, spec)
             DB.session.commit()
@@ -73,13 +91,14 @@ def make_plot_builder_blueprint(
             marks=MARKS,
             discrete=VARIABLES_1,
             continuous=VARIABLES_2,
+            group_by=GROUP_BY_VARIABLES,
             plot=plot,
             spec=spec,
         )
 
     @blueprint.route("/delete/<int:id>")
     @needs_authentication(authenticator)
-    def delete(id: int) -> Response:
+    def delete(id: int) -> ResponseReturnValue:
         spec = DB.session.get(PlotSpec, id)
         DB.session.delete(spec)
         flasher.flash_message(f"Deleted plot '{spec.name}'.", FlashTypes.SUCCESS)

geo_activity_playground/webui/blueprints/summary_blueprint.py

@@ -1,4 +1,3 @@
-import collections
 import datetime
 
 import altair as alt
@@ -9,224 +8,41 @@ from flask import render_template
 from flask import request
 
 from ...core.activities import ActivityRepository
-from ...core.activities import make_geojson_from_time_series
 from ...core.config import Config
 from ...core.datamodel import DB
 from ...core.datamodel import PlotSpec
 from ...core.meta_search import apply_search_query
 from ...core.parametric_plot import make_parametric_plot
-from ..columns import column_distance
-from ..columns import column_elevation_gain
 from ..columns import ColumnDescription
+from ..columns import META_COLUMNS
 from ..plot_util import make_kind_scale
 from ..search_util import search_query_from_form
 from ..search_util import SearchQueryHistory
 
 
-def make_summary_blueprint(
-    repository: ActivityRepository,
-    config: Config,
-    search_query_history: SearchQueryHistory,
-) -> Blueprint:
-    blueprint = Blueprint("summary", __name__, template_folder="templates")
-
-    @blueprint.route("/")
-    def index():
-        query = search_query_from_form(request.args)
-        search_query_history.register_query(query)
-        activities = apply_search_query(repository.meta, query)
-
-        kind_scale = make_kind_scale(repository.meta, config)
-        df = activities
-
-        nominations = nominate_activities(df)
-
-        return render_template(
-            "summary/index.html.j2",
-            plot_distance_heatmaps=plot_heatmaps(df, column_distance, config),
-            plot_elevation_gain_heatmaps=plot_heatmaps(
-                df, column_elevation_gain, config
-            ),
-            plot_monthly_distance=plot_monthly_sums(df, column_distance, kind_scale),
-            plot_monthly_elevation_gain=plot_monthly_sums(
-                df, column_elevation_gain, kind_scale
-            ),
-            plot_yearly_distance=plot_yearly_sums(df, column_distance, kind_scale),
-            plot_yearly_elevation_gain=plot_yearly_sums(
-                df, column_elevation_gain, kind_scale
-            ),
-            plot_year_cumulative=plot_year_cumulative(df, column_distance),
-            plot_year_elevation_gain_cumulative=plot_year_cumulative(
-                df, column_elevation_gain
-            ),
-            tabulate_year_kind_mean=tabulate_year_kind_mean(df, column_distance)
-            .reset_index()
-            .to_dict(orient="split"),
-            tabulate_year_kind_mean_elevation_gain=tabulate_year_kind_mean(
-                df, column_elevation_gain
-            )
-            .reset_index()
-            .to_dict(orient="split"),
-            plot_weekly_distance=plot_weekly_sums(df, column_distance, kind_scale),
-            plot_weekly_elevation_gain=plot_weekly_sums(
-                df, column_elevation_gain, kind_scale
-            ),
-            nominations=[
-                (
-                    repository.get_activity_by_id(activity_id),
-                    reasons,
-                    make_geojson_from_time_series(
-                        repository.get_time_series(activity_id)
-                    ),
-                )
-                for activity_id, reasons in nominations.items()
-            ],
-            query=query.to_jinja(),
-            custom_plots=[
-                (spec, make_parametric_plot(repository.meta, spec))
-                for spec in DB.session.scalars(sqlalchemy.select(PlotSpec)).all()
-            ],
-        )
-
-    return blueprint
-
-
-def nominate_activities(meta: pd.DataFrame) -> dict[int, list[str]]:
-    nominations: dict[int, list[str]] = collections.defaultdict(list)
-
-    _nominate_activities_inner(meta, "", nominations)
-
-    for kind, group in meta.groupby("kind"):
-        _nominate_activities_inner(group, f" for {kind}", nominations)
-    for equipment, group in meta.groupby("equipment"):
-        _nominate_activities_inner(group, f" with {equipment}", nominations)
-
-    return nominations
-
-
-def _nominate_activities_inner(
-    meta: pd.DataFrame, title_suffix: str, nominations: dict[int, list[str]]
-) -> None:
-    ratings = [
-        ("distance_km", "Greatest distance", "{:.1f} km"),
-        ("elapsed_time", "Longest elapsed time", "{}"),
-        ("average_speed_moving_kmh", "Highest average moving speed", "{:.1f} km/h"),
-        ("average_speed_elapsed_kmh", "Highest average elapsed speed", "{:.1f} km/h"),
-        ("calories", "Most calories burnt", "{:.0f}"),
-        ("steps", "Most steps", "{:.0f}"),
-        ("elevation_gain", "Largest elevation gain", "{:.0f} m"),
-    ]
-
-    for variable, title, format_str in ratings:
-        if variable in meta.columns and not pd.isna(meta[variable]).all():
-            i = meta[variable].idxmax()
-            value = meta.loc[i, variable]
-            format_applied = format_str.format(value)
-            nominations[i].append(f"{title}{title_suffix}: {format_applied}")
-
-
-def plot_heatmaps(
-    meta: pd.DataFrame, column: ColumnDescription, config: Config
-) -> dict[int, str]:
-    return {
-        year: alt.Chart(
-            meta.loc[(meta["year"] == year)],
-            title=f"Daily {column.display_name} Heatmap",
-        )
-        .mark_rect()
-        .encode(
-            alt.X("date(start):O", title="Day of month"),
-            alt.Y(
-                "yearmonth(start):O",
-                # scale=alt.Scale(reverse=True),
-                title="Year and month",
-            ),
-            alt.Color(
-                f"sum({column.name})",
-                scale=alt.Scale(scheme=config.color_scheme_for_counts),
-            ),
-            [
-                alt.Tooltip("yearmonthdate(start)", title="Date"),
-                alt.Tooltip(
-                    f"sum({column.name})",
-                    format=column.format,
-                    title=f"Total {column.display_name} / {column.unit}",
-                ),
-                alt.Tooltip(f"count({column.name})", title="Number of activities"),
-            ],
-        )
-        .to_json(format="vega")
-        for year in sorted(meta["year"].unique())
-    }
-
-
-def plot_monthly_sums(
-    meta: pd.DataFrame, column: ColumnDescription, kind_scale: alt.Scale
-) -> str:
+def plot_per_year_per_kind(df: pd.DataFrame, column: ColumnDescription) -> str:
     return (
         alt.Chart(
-            meta.loc[
-                (
-                    meta["start"]
-                    >= pd.to_datetime(
-                        datetime.datetime.now() - datetime.timedelta(days=2 * 365)
-                    )
-                )
-            ],
-            title=f"Monthly {column.display_name}",
+            df,
+            title=f"{column.display_name} per Year",
         )
         .mark_bar()
         .encode(
-            alt.X("month(start)", title="Month"),
+            alt.X("year:O", title="Year"),
             alt.Y(
-                f"sum({column.name})",
-                title=f"{column.display_name} / {column.unit}",
+                f"sum({column.name})", title=f"{column.display_name} / {column.unit}"
             ),
-            alt.Color("kind", scale=kind_scale, title="Kind"),
-            alt.Column("year(start):O", title="Year"),
+            alt.Color("kind", title="Kind"),
             [
-                alt.Tooltip("yearmonth(start)", title="Year and Month"),
+                alt.Tooltip("year", title="Year"),
                 alt.Tooltip("kind", title="Kind"),
                 alt.Tooltip(
                     f"sum({column.name})",
-                    format=column.format,
-                    title=f"Total {column.display_name} / {column.unit}",
-                ),
-                alt.Tooltip(f"count({column.name})", title="Number of activities"),
-            ],
-        )
-        .resolve_axis(x="independent")
-        .to_json(format="vega")
-    )
-
-
-def plot_yearly_sums(
-    df: pd.DataFrame, column: ColumnDescription, kind_scale: alt.Scale
-) -> str:
-    year_kind_total = (
-        df[["year", "kind", column.name, "hours"]]
-        .groupby(["year", "kind"])
-        .sum()
-        .reset_index()
-    )
-
-    return (
-        alt.Chart(year_kind_total, title=f"Total {column.display_name} per Year")
-        .mark_bar()
-        .encode(
-            alt.X("year:O", title="Year"),
-            alt.Y(column.name, title=f"{column.display_name} / {column.unit}"),
-            alt.Color("kind", scale=kind_scale, title="Kind"),
-            [
-                alt.Tooltip("year:O", title="Year"),
-                alt.Tooltip("kind", title="Kind"),
-                alt.Tooltip(
-                    column.name,
                     title=f"{column.display_name} / {column.unit}",
-                    format=column.format,
                 ),
             ],
         )
+        .interactive()
         .to_json(format="vega")
     )
 
@@ -250,7 +66,6 @@ def plot_year_cumulative(df: pd.DataFrame, column: ColumnDescription) -> str:
     return (
         alt.Chart(
             year_cumulative,
-            width=500,
             title=f"Cumulative {column.display_name} per Year",
         )
         .mark_line()
@@ -273,65 +88,124 @@ def plot_year_cumulative(df: pd.DataFrame, column: ColumnDescription) -> str:
     )
 
 
-def tabulate_year_kind_mean(
-    df: pd.DataFrame, column: ColumnDescription
-) -> pd.DataFrame:
-    year_kind_mean = (
-        df[["year", "kind", column.name, "hours"]]
-        .groupby(["year", "kind"])
-        .mean()
-        .reset_index()
-    )
-
-    year_kind_mean_distance = year_kind_mean.pivot(
-        index="year", columns="kind", values=column.name
-    )
-
-    return year_kind_mean_distance
-
-
-def plot_weekly_sums(
-    df: pd.DataFrame, column: ColumnDescription, kind_scale: alt.Scale
-) -> str:
-    week_kind_total_distance = (
-        df[["iso_year", "week", "kind", column.name]]
-        .groupby(["iso_year", "week", "kind"])
-        .sum()
-        .reset_index()
-    )
-    week_kind_total_distance["year_week"] = [
-        f"{year}-{week:02d}"
-        for year, week in zip(
-            week_kind_total_distance["iso_year"], week_kind_total_distance["week"]
+def plot_per_iso_week(df: pd.DataFrame, column: ColumnDescription) -> str:
+    return (
+        alt.Chart(
+            df,
+            title=f"{column.display_name} per Week",
         )
-    ]
+        .mark_circle()
+        .encode(
+            alt.X("week:O", title="ISO Week"),
+            alt.Y("iso_year:O", title="ISO Year"),
+            alt.Size(
+                f"sum({column.name})", title=f"{column.display_name} / {column.unit}"
+            ),
+            [
+                alt.Tooltip("iso_year", title="ISO Year"),
+                alt.Tooltip("week", title="ISO Week"),
+                alt.Tooltip(
+                    f"sum({column.name})",
+                    title=f"{column.display_name} / {column.unit}",
+                    format=column.format,
+                ),
+            ],
+        )
+        .interactive()
+        .to_json(format="vega")
+    )
 
-    last_year = week_kind_total_distance["iso_year"].iloc[-1]
-    last_week = week_kind_total_distance["week"].iloc[-1]
 
+def heatmap_per_day(df: pd.DataFrame, column: ColumnDescription) -> str:
     return (
         alt.Chart(
-            week_kind_total_distance.loc[
-                (week_kind_total_distance["iso_year"] == last_year)
-                | (week_kind_total_distance["iso_year"] == last_year - 1)
-                & (week_kind_total_distance["week"] >= last_week)
-            ],
-            title=f"Weekly {column.display_name}",
+            _filter_past_year(df),
+            title=f"{column.display_name} per day",
         )
-        .mark_bar()
+        .mark_rect()
         .encode(
-            alt.X("year_week", title="Year and Week"),
-            alt.Y(column.name, title=f"{column.display_name} / {column.unit}"),
-            alt.Color("kind", scale=kind_scale, title="Kind"),
+            alt.X("iso_year_week:O", title="ISO Year and Week"),
+            alt.Y(
+                "iso_day:O",
+                # scale=alt.Scale(
+                #     domain=list(range(1, 8)),
+                #     range=[
+                #         "Monday",
+                #         "Tuesday",
+                #         "Wednesday",
+                #         "Thursday",
+                #         "Friday",
+                #         "Saturday",
+                #         "Sunday",
+                #     ],
+                # ),
+                title="ISO Weekday",
+            ),
+            alt.Color(
+                f"sum({column.name})",
+                scale=alt.Scale(scheme="viridis"),
+                title=f"{column.display_name} / {column.unit}",
+            ),
             [
-                alt.Tooltip("year_week", title="Year and Week"),
-                alt.Tooltip("kind", title="Kind"),
+                alt.Tooltip("iso_year_week", title="ISO Year and Week"),
+                alt.Tooltip("iso_day", title="ISO Day"),
                 alt.Tooltip(
-                    column.name,
+                    f"sum({column.name})",
                     title=f"{column.display_name} / {column.unit}",
                     format=column.format,
                 ),
             ],
         )
+        .interactive()
         .to_json(format="vega")
     )
+
+
+def _filter_past_year(df: pd.DataFrame) -> pd.DataFrame:
+    now = datetime.datetime.combine(datetime.date.today(), datetime.time.min)
+    start = now - datetime.timedelta(days=365)
+    return df.loc[df["start"] >= start]
+
+
+def make_summary_blueprint(
+    repository: ActivityRepository,
+    config: Config,
+    search_query_history: SearchQueryHistory,
+) -> Blueprint:
+    blueprint = Blueprint("summary", __name__, template_folder="templates")
+
+    @blueprint.route("/")
+    def index():
+        query = search_query_from_form(request.args)
+        search_query_history.register_query(query)
+        activities = apply_search_query(repository.meta, query)
+
+        kind_scale = make_kind_scale(repository.meta, config)
+        df = activities
+
+        return render_template(
+            "summary/index.html.j2",
+            query=query.to_jinja(),
+            custom_plots=[
+                (spec, make_parametric_plot(repository.meta, spec))
+                for spec in DB.session.scalars(sqlalchemy.select(PlotSpec)).all()
+            ],
+            plot_per_year_per_kind={
+                column.display_name: plot_per_year_per_kind(df, column)
+                for column in META_COLUMNS
+            },
+            plot_per_year_cumulative={
+                column.display_name: plot_year_cumulative(df, column)
+                for column in META_COLUMNS
+            },
+            plot_per_iso_week={
+                column.display_name: plot_per_iso_week(df, column)
+                for column in META_COLUMNS
+            },
+            heatmap_per_day={
+                column.display_name: heatmap_per_day(df, column)
+                for column in META_COLUMNS
+            },
+        )
+
+    return blueprint

geo_activity_playground/webui/blueprints/upload_blueprint.py

@@ -25,6 +25,8 @@ from ...importers.strava_api import import_from_strava_api
 from ...importers.strava_checkout import import_from_strava_checkout
 from ..authenticator import Authenticator
 from ..authenticator import needs_authentication
+from ..flasher import Flasher
+from ..flasher import FlashTypes
 
 
 def make_upload_blueprint(
@@ -32,6 +34,7 @@ def make_upload_blueprint(
     tile_visit_accessor: TileVisitAccessor,
     config: Config,
     authenticator: Authenticator,
+    flasher: Flasher,
 ) -> Blueprint:
     blueprint = Blueprint("upload", __name__, template_folder="templates")
 
@@ -72,6 +75,12 @@ def make_upload_blueprint(
                 ".tcx",
             ]
             assert target_path.is_relative_to("Activities")
+            if target_path.exists():
+                flasher.flash_message(
+                    f"An activity with path '{target_path}' already exists. Rename the file and try again.",
+                    FlashTypes.DANGER,
+                )
+                return redirect(url_for(".index"))
             file.save(target_path)
             scan_for_activities(
                 repository,