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

geo_activity_playground/webui/blueprints/explorer_blueprint.py

@@ -1,12 +1,15 @@
 import datetime
+import io
 import itertools
 import logging
 
 import altair as alt
 import geojson
 import matplotlib
+import matplotlib.pyplot as pl
 import numpy as np
 import pandas as pd
+import sqlalchemy
 from flask import Blueprint
 from flask import flash
 from flask import redirect
@@ -17,6 +20,10 @@ from flask import url_for
 from ...core.activities import ActivityRepository
 from ...core.config import ConfigAccessor
 from ...core.coordinates import Bounds
+from ...core.datamodel import Activity
+from ...core.datamodel import DB
+from ...core.raster_map import ImageTransform
+from ...core.raster_map import TileGetter
 from ...core.tiles import compute_tile
 from ...core.tiles import get_tile_upper_left_lat_lon
 from ...explorer.grid_file import get_border_tiles
@@ -38,9 +45,10 @@ logger = logging.getLogger(__name__)
 
 def make_explorer_blueprint(
     authenticator: Authenticator,
-    repository: ActivityRepository,
     tile_visit_accessor: TileVisitAccessor,
     config_accessor: ConfigAccessor,
+    tile_getter: TileGetter,
+    image_transforms: dict[str, ImageTransform],
 ) -> Blueprint:
     blueprint = Blueprint("explorer", __name__, template_folder="templates")
 
@@ -59,7 +67,7 @@ def make_explorer_blueprint(
         )
 
         explored = get_three_color_tiles(
-            tile_visits[zoom], repository, tile_evolution_states[zoom], zoom
+            tile_visits[zoom], tile_evolution_states[zoom], zoom
         )
 
         context = {
@@ -151,12 +159,74 @@ def make_explorer_blueprint(
             headers={"Content-disposition": "attachment"},
         )
 
+    @blueprint.route("/<int:zoom>/server-side")
+    def server_side(zoom: int):
+        if zoom not in config_accessor().explorer_zoom_levels:
+            return {"zoom_level_not_generated": zoom}
+
+        tile_evolution_states = tile_visit_accessor.tile_state["evolution_state"]
+        tile_histories = tile_visit_accessor.tile_state["tile_history"]
+
+        medians = tile_histories[zoom].median()
+        median_lat, median_lon = get_tile_upper_left_lat_lon(
+            medians["tile_x"], medians["tile_y"], zoom
+        )
+
+        context = {
+            "center": {
+                "latitude": median_lat,
+                "longitude": median_lon,
+                "bbox": (
+                    bounding_box_for_biggest_cluster(
+                        tile_evolution_states[zoom].clusters.values(), zoom
+                    )
+                    if len(tile_evolution_states[zoom].memberships) > 0
+                    else {}
+                ),
+            },
+            "plot_tile_evolution": plot_tile_evolution(tile_histories[zoom]),
+            "plot_cluster_evolution": plot_cluster_evolution(
+                tile_evolution_states[zoom].cluster_evolution
+            ),
+            "plot_square_evolution": plot_square_evolution(
+                tile_evolution_states[zoom].square_evolution
+            ),
+            "zoom": zoom,
+        }
+        return render_template("explorer/server-side.html.j2", **context)
+
+    @blueprint.route("/<int:zoom>/tile/<int:z>/<int:x>/<int:y>.png")
+    def tile(zoom: int, z: int, x: int, y: int) -> Response:
+        tile_visits = tile_visit_accessor.tile_state["tile_visits"][zoom]
+
+        map_tile = np.array(tile_getter.get_tile(z, x, y)) / 255
+        if z >= zoom:
+            factor = 2 ** (z - zoom)
+            if (x // factor, y // factor) in tile_visits:
+                map_tile = image_transforms["color"].transform_image(map_tile)
+            else:
+                map_tile = image_transforms["color"].transform_image(map_tile) / 1.2
+        else:
+            grayscale = image_transforms["color"].transform_image(map_tile) / 1.2
+            factor = 2 ** (zoom - z)
+            width = 256 // factor
+            for xo in range(factor):
+                for yo in range(factor):
+                    if (x * factor + xo, y * factor + yo) not in tile_visits:
+                        map_tile[
+                            yo * width : (yo + 1) * width, xo * width : (xo + 1) * width
+                        ] = grayscale[
+                            yo * width : (yo + 1) * width, xo * width : (xo + 1) * width
+                        ]
+        f = io.BytesIO()
+        pl.imsave(f, map_tile, format="png")
+        return Response(bytes(f.getbuffer()), mimetype="image/png")
+
     return blueprint
 
 
 def get_three_color_tiles(
     tile_visits: dict,
-    repository: ActivityRepository,
     cluster_state: TileEvolutionState,
     zoom: int,
 ) -> str:
@@ -174,13 +244,17 @@ def get_three_color_tiles(
             last_age_days = 10000
         tile_dict[tile] = {
             "first_activity_id": str(tile_data["first_id"]),
-            "first_activity_name": repository.get_activity_by_id(tile_data["first_id"])[
-                "name"
-            ],
+            "first_activity_name": DB.session.scalar(
+                sqlalchemy.select(Activity.name).where(
+                    Activity.id == tile_data["first_id"]
+                )
+            ),
             "last_activity_id": str(tile_data["last_id"]),
-            "last_activity_name": repository.get_activity_by_id(tile_data["last_id"])[
-                "name"
-            ],
+            "last_activity_name": DB.session.scalar(
+                sqlalchemy.select(Activity.name).where(
+                    Activity.id == tile_data["last_id"]
+                )
+            ),
             "first_age_days": first_age_days,
             "first_age_color": matplotlib.colors.to_hex(
                 cmap_first(max(1 - first_age_days / (2 * 365), 0.0))

geo_activity_playground/webui/blueprints/settings_blueprint.py

@@ -18,6 +18,7 @@ from ...core.config import ConfigAccessor
 from ...core.datamodel import DB
 from ...core.datamodel import Equipment
 from ...core.datamodel import Kind
+from ...core.datamodel import Tag
 from ...core.heart_rate import HeartRateZoneComputer
 from ...core.paths import _activity_enriched_dir
 from ..authenticator import Authenticator
@@ -395,6 +396,37 @@ def make_settings_blueprint(
         strava_login_helper.save_strava_code(code)
         return redirect(url_for(".strava"))
 
+    @blueprint.route("/tags")
+    @needs_authentication(authenticator)
+    def tags_list():
+        return render_template(
+            "settings/tags-list.html.j2",
+            tags=DB.session.scalars(sqlalchemy.select(Tag)).all(),
+        )
+
+    @blueprint.route("/tags/new", methods=["GET", "POST"])
+    @needs_authentication(authenticator)
+    def tags_new():
+        if request.method == "POST":
+            tag_str = request.form["tag"]
+            tag = Tag(tag=tag_str)
+            DB.session.add(tag)
+            DB.session.commit()
+            return redirect(url_for(".tags_list"))
+        else:
+            return render_template("settings/tags-new.html.j2")
+
+    @blueprint.route("/tags/edit/<int:id>", methods=["GET", "POST"])
+    @needs_authentication(authenticator)
+    def tags_edit(id: int):
+        tag = DB.session.get_one(Tag, id)
+        if request.method == "POST":
+            tag.tag = request.form["tag"]
+            DB.session.commit()
+            return redirect(url_for(".tags_list"))
+        else:
+            return render_template("settings/tags-edit.html.j2", tag=tag)
+
     return blueprint
 
 

geo_activity_playground/webui/blueprints/summary_blueprint.py

@@ -15,6 +15,9 @@ 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 ..plot_util import make_kind_scale
 from ..search_util import search_query_from_form
 from ..search_util import SearchQueryHistory
@@ -36,25 +39,38 @@ def make_summary_blueprint(
         kind_scale = make_kind_scale(repository.meta, config)
         df = activities
 
-        year_kind_total = (
-            df[["year", "kind", "distance_km", "hours"]]
-            .groupby(["year", "kind"])
-            .sum()
-            .reset_index()
-        )
-
         nominations = nominate_activities(df)
 
         return render_template(
             "summary/index.html.j2",
-            plot_distance_heatmaps=plot_distance_heatmaps(df, config),
-            plot_monthly_distance=plot_monthly_distance(df, kind_scale),
-            plot_yearly_distance=plot_yearly_distance(year_kind_total, kind_scale),
-            plot_year_cumulative=plot_year_cumulative(df),
-            tabulate_year_kind_mean=tabulate_year_kind_mean(df)
+            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"),
-            plot_weekly_distance=plot_weekly_distance(df, kind_scale),
+            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),
@@ -109,11 +125,13 @@ def _nominate_activities_inner(
             nominations[i].append(f"{title}{title_suffix}: {format_applied}")
 
 
-def plot_distance_heatmaps(meta: pd.DataFrame, config: Config) -> dict[int, str]:
+def plot_heatmaps(
+    meta: pd.DataFrame, column: ColumnDescription, config: Config
+) -> dict[int, str]:
     return {
         year: alt.Chart(
             meta.loc[(meta["year"] == year)],
-            title="Daily Distance Heatmap",
+            title=f"Daily {column.display_name} Heatmap",
         )
         .mark_rect()
         .encode(
@@ -124,15 +142,17 @@ def plot_distance_heatmaps(meta: pd.DataFrame, config: Config) -> dict[int, str]
                 title="Year and month",
             ),
             alt.Color(
-                "sum(distance_km)",
+                f"sum({column.name})",
                 scale=alt.Scale(scheme=config.color_scheme_for_counts),
             ),
             [
                 alt.Tooltip("yearmonthdate(start)", title="Date"),
                 alt.Tooltip(
-                    "sum(distance_km)", format=".1f", title="Total distance / km"
+                    f"sum({column.name})",
+                    format=column.format,
+                    title=f"Total {column.display_name} / {column.unit}",
                 ),
-                alt.Tooltip("count(distance_km)", title="Number of activities"),
+                alt.Tooltip(f"count({column.name})", title="Number of activities"),
             ],
         )
         .to_json(format="vega")
@@ -140,7 +160,9 @@ def plot_distance_heatmaps(meta: pd.DataFrame, config: Config) -> dict[int, str]
     }
 
 
-def plot_monthly_distance(meta: pd.DataFrame, kind_scale: alt.Scale) -> str:
+def plot_monthly_sums(
+    meta: pd.DataFrame, column: ColumnDescription, kind_scale: alt.Scale
+) -> str:
     return (
         alt.Chart(
             meta.loc[
@@ -151,20 +173,26 @@ def plot_monthly_distance(meta: pd.DataFrame, kind_scale: alt.Scale) -> str:
                     )
                 )
             ],
-            title="Monthly Distance",
+            title=f"Monthly {column.display_name}",
         )
         .mark_bar()
         .encode(
             alt.X("month(start)", title="Month"),
-            alt.Y("sum(distance_km)", title="Distance / km"),
+            alt.Y(
+                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.Tooltip("yearmonthdate(start)", title="Date"),
+                alt.Tooltip("yearmonth(start)", title="Year and Month"),
+                alt.Tooltip("kind", title="Kind"),
                 alt.Tooltip(
-                    "sum(distance_km)", format=".1f", title="Total distance / km"
+                    f"sum({column.name})",
+                    format=column.format,
+                    title=f"Total {column.display_name} / {column.unit}",
                 ),
-                alt.Tooltip("count(distance_km)", title="Number of activities"),
+                alt.Tooltip(f"count({column.name})", title="Number of activities"),
             ],
         )
         .resolve_axis(x="independent")
@@ -172,31 +200,47 @@ def plot_monthly_distance(meta: pd.DataFrame, kind_scale: alt.Scale) -> str:
     )
 
 
-def plot_yearly_distance(year_kind_total: pd.DataFrame, kind_scale: alt.Scale) -> str:
+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="Total Distance per Year")
+        alt.Chart(year_kind_total, title=f"Total {column.display_name} per Year")
         .mark_bar()
         .encode(
             alt.X("year:O", title="Year"),
-            alt.Y("distance_km", title="Distance / km"),
+            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("distance_km", title="Distance / km", format=".1f"),
+                alt.Tooltip(
+                    column.name,
+                    title=f"{column.display_name} / {column.unit}",
+                    format=column.format,
+                ),
             ],
         )
         .to_json(format="vega")
     )
 
 
-def plot_year_cumulative(df: pd.DataFrame) -> str:
+def plot_year_cumulative(df: pd.DataFrame, column: ColumnDescription) -> str:
     year_cumulative = (
-        df[["iso_year", "week", "distance_km"]]
+        df[["iso_year", "week", column.name]]
         .groupby("iso_year")
         .apply(
             lambda group: pd.DataFrame(
-                {"week": group["week"], "distance_km": group["distance_km"].cumsum()}
+                {
+                    "week": group["week"],
+                    column.name: group[column.name].cumsum(),
+                }
             ),
             include_groups=False,
         )
@@ -204,16 +248,24 @@ def plot_year_cumulative(df: pd.DataFrame) -> str:
     )
 
     return (
-        alt.Chart(year_cumulative, width=500, title="Cumultative Distance per Year")
+        alt.Chart(
+            year_cumulative,
+            width=500,
+            title=f"Cumulative {column.display_name} per Year",
+        )
         .mark_line()
         .encode(
             alt.X("week", title="Week"),
-            alt.Y("distance_km", title="Distance / km"),
+            alt.Y(column.name, title=f"{column.display_name} / {column.unit}"),
             alt.Color("iso_year:N", title="Year"),
             [
                 alt.Tooltip("week", title="Week"),
                 alt.Tooltip("iso_year:N", title="Year"),
-                alt.Tooltip("distance_km", title="Distance / km", format=".1f"),
+                alt.Tooltip(
+                    column.name,
+                    title=f"{column.display_name} / {column.unit}",
+                    format=column.format,
+                ),
             ],
         )
         .interactive()
@@ -221,24 +273,28 @@ def plot_year_cumulative(df: pd.DataFrame) -> str:
     )
 
 
-def tabulate_year_kind_mean(df: pd.DataFrame) -> pd.DataFrame:
+def tabulate_year_kind_mean(
+    df: pd.DataFrame, column: ColumnDescription
+) -> pd.DataFrame:
     year_kind_mean = (
-        df[["year", "kind", "distance_km", "hours"]]
+        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="distance_km"
+        index="year", columns="kind", values=column.name
     )
 
     return year_kind_mean_distance
 
 
-def plot_weekly_distance(df: pd.DataFrame, kind_scale: alt.Scale) -> str:
+def plot_weekly_sums(
+    df: pd.DataFrame, column: ColumnDescription, kind_scale: alt.Scale
+) -> str:
     week_kind_total_distance = (
-        df[["iso_year", "week", "kind", "distance_km"]]
+        df[["iso_year", "week", "kind", column.name]]
         .groupby(["iso_year", "week", "kind"])
         .sum()
         .reset_index()
@@ -260,17 +316,21 @@ def plot_weekly_distance(df: pd.DataFrame, kind_scale: alt.Scale) -> str:
                 | (week_kind_total_distance["iso_year"] == last_year - 1)
                 & (week_kind_total_distance["week"] >= last_week)
             ],
-            title="Weekly Distance",
+            title=f"Weekly {column.display_name}",
         )
         .mark_bar()
         .encode(
             alt.X("year_week", title="Year and Week"),
-            alt.Y("distance_km", title="Distance / km"),
+            alt.Y(column.name, title=f"{column.display_name} / {column.unit}"),
             alt.Color("kind", scale=kind_scale, title="Kind"),
             [
                 alt.Tooltip("year_week", title="Year and Week"),
                 alt.Tooltip("kind", title="Kind"),
-                alt.Tooltip("distance_km", title="Distance / km", format=".1f"),
+                alt.Tooltip(
+                    column.name,
+                    title=f"{column.display_name} / {column.unit}",
+                    format=column.format,
+                ),
             ],
         )
         .to_json(format="vega")

geo_activity_playground/webui/columns.py

@@ -0,0 +1,37 @@
+import dataclasses
+
+
+@dataclasses.dataclass
+class ColumnDescription:
+    name: str
+    display_name: str
+    unit: str
+    format: str
+
+
+column_distance = ColumnDescription(
+    name="distance_km",
+    display_name="Distance",
+    unit="km",
+    format=".1f",
+)
+
+column_elevation = ColumnDescription(
+    name="elevation",
+    display_name="Elevation",
+    unit="m",
+    format=".0f",
+)
+column_elevation_gain = ColumnDescription(
+    name="elevation_gain",
+    display_name="Elevation Gain",
+    unit="m",
+    format=".0f",
+)
+
+column_speed = ColumnDescription(
+    name="speed",
+    display_name="Speed",
+    unit="km/h",
+    format=".1f",
+)

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

@@ -32,6 +32,21 @@
         </select>
     </div>
 
+    <div class="mb-3">
+        <label for="" class="form-label">Tags</label>
+        <div class="form-control">
+            {% for tag in tags %}
+            <div class="form-check form-check-inline">
+                <input class="form-check-input" type="checkbox" name="tag" value="{{ tag.id }}" id="tag_{{ tag.id }}" {%
+                    if tag in activity.tags %} checked {% endif %}>
+                <label class="form-check-label" for="tag_{{ tag.id }}">
+                    {{ tag.tag }}
+                </label>
+            </div>
+            {% endfor %}
+        </div>
+    </div>
+
     <button type="submit" class="btn btn-primary">Save</button>
 </form>
 

geo_activity_playground/webui/templates/activity/show.html.j2

@@ -11,13 +11,22 @@
     <div class="col-sm-12 col-md-4">
         <dl>
             <dt>Name</dt>
-            <dd>{{ activity["name"] }}</dd>
+            <dd>{{ activity.name }}</dd>
 
             {% if activity.kind %}
             <dt>Kind</dt>
             <dd>{{ activity.kind.name }}</dd>
             {% endif %}
 
+            {% if activity.tags %}
+            <dt>Tags</dt>
+            <dd>
+                {% for tag in activity.tags %}
+                <span class="badge text-bg-primary">{{ tag.tag }}</span>
+                {% endfor %}
+            </dd>
+            {% endif %}
+
             <dt>Distance</dt>
             <dd>{{ activity.distance_km|round(1) }} km</dd>
 
@@ -49,7 +58,7 @@
 
             {% if activity.elevation_gain %}
             <dt>Elevation gain</dt>
-            <dd>{{ activity.elevation_gain|round(0) }} m</dd>
+            <dd>{{ activity.elevation_gain|round(0)|int }} m</dd>
             {% endif %}
 
             {% if activity.equipment %}
@@ -105,10 +114,23 @@
         </style>
 
         <div>
-            {% for speed, color in speed_color_bar.colors %}
-            <span class="colorbar" style="width: 15px; background-color: {{ color }}">{{ speed }}</span>
+            {% for value, color in line_color_bar.colors %}
+            <span class="colorbar" style="width: 15px; background-color: {{ color }}">{{ value }}</span>
             {% endfor %}
-            km/h
+            {{ line_color_columns_avail[line_color_column].unit }}
+        </div>
+
+        <div class="mb-3" style="padding-top: 10px;">
+            <form method="GET">
+                <label class="form-label">Line Color by</label>
+                <select class="form-select" aria-label="Line Color by" name="line_color_column"
+                    onchange="this.form.submit()">
+                    {% for name, column in line_color_columns_avail.items() %}
+                    <option {% if name==line_color_column %} selected {% endif %} value="{{ name }}">{{
+                        column.display_name }}</option>
+                    {% endfor %}
+                </select>
+            </form>
         </div>
     </div>
 </div>

geo_activity_playground/webui/templates/bubble_chart/index.html.j2

@@ -1,17 +1,33 @@
-<!-- filepath: /home/michael/Nextcloud/Python/Geoactivity-Fork/geo-activity-playground/geo_activity_playground/webui/templates/bubble_chart/index.html.j2 -->
 {% extends "page.html.j2" %}
 
 {% block container %}
+
+<div class="row mb-3">
+    <div class="col">
+        <h1>Bubble Chart: Distance</h1>
+        <div id="bubble-chart-distance"></div>
+        <script>
+            const chartSpecDistance = {{ bubble_chart_distance | safe }};
+            vegaEmbed('#bubble-chart-distance', chartSpecDistance).then((result) => {
+                // Add a click event listener to the chart
+                result.view.addEventListener('click', (event, item) => {
+                    if (item && item.datum && item.datum.activity_url) {
+                        // Redirect to the activity URL
+                        window.location.href = item.datum.activity_url;
+                    }
+                });
+            }).catch(console.error);
+        </script>
+    </div>
+</div>
+
 <div class="row mb-3">
     <div class="col">
-        <h1>Bubble Chart</h1>
-        <div id="bubble-chart"></div>
-        <script src="https://cdn.jsdelivr.net/npm/vega@5"></script>
-        <script src="https://cdn.jsdelivr.net/npm/vega-lite@5"></script>
-        <script src="https://cdn.jsdelivr.net/npm/vega-embed@6"></script>
+        <h1>Bubble Chart: Elevation Gain</h1>
+        <div id="bubble-chart-elevation-gain"></div>
         <script>
-            const chartSpec = {{ bubble_chart | safe }};
-            vegaEmbed('#bubble-chart', chartSpec).then((result) => {
+            const chartSpecElevationGain = {{ bubble_chart_elevation_gain | safe }};
+            vegaEmbed('#bubble-chart-elevation-gain', chartSpecElevationGain).then((result) => {
                 // Add a click event listener to the chart
                 result.view.addEventListener('click', (event, item) => {
                     if (item && item.datum && item.datum.activity_url) {