geo-activity-playground 0.37.0__tar.gz → 0.38.0__tar.gz

{geo_activity_playground-0.37.0 → geo_activity_playground-0.38.0}/PKG-INFO

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

{geo_activity_playground-0.37.0 → geo_activity_playground-0.38.0}/geo_activity_playground/core/activities.py

@@ -24,11 +24,14 @@ logger = logging.getLogger(__name__)
 
 
 class ActivityMeta(TypedDict):
+    average_speed_elapsed_kmh: float
+    average_speed_moving_kmh: float
     calories: float
     commute: bool
     consider_for_achievements: bool
     distance_km: float
     elapsed_time: datetime.timedelta
+    elevation_gain: float
     end_latitude: float
     end_longitude: float
     equipment: str
@@ -110,6 +113,15 @@ def build_activity_meta() -> None:
 
         meta.sort_values("start", inplace=True)
 
+        meta.loc[meta["kind"] == "", "kind"] = "Unknown"
+        meta.loc[meta["equipment"] == "", "equipment"] = "Unknown"
+        meta["average_speed_moving_kmh"] = meta["distance_km"] / (
+            meta["moving_time"].dt.total_seconds() / 3_600
+        )
+        meta["average_speed_elapsed_kmh"] = meta["distance_km"] / (
+            meta["elapsed_time"].dt.total_seconds() / 3_600
+        )
+
     meta.to_parquet(activities_file())
 
 

{geo_activity_playground-0.37.0 → geo_activity_playground-0.38.0}/geo_activity_playground/core/config.py

@@ -45,7 +45,12 @@ class Config:
     time_diff_threshold_seconds: Optional[int] = 30
     upload_password: Optional[str] = None
     map_tile_url: str = "https://tile.openstreetmap.org/{zoom}/{x}/{y}.png"
-    map_tile_attribution: str = '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a> | <a href="https://www.openstreetmap.org/fixthemap">Correct Map</a>'
+    map_tile_attribution: str = (
+        '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a> | <a href="https://www.openstreetmap.org/fixthemap">Correct Map</a>'
+    )
+    search_queries_favorites: list[dict] = dataclasses.field(default_factory=list)
+    search_queries_last: list[dict] = dataclasses.field(default_factory=list)
+    search_queries_num_keep: int = 10
 
 
 class ConfigAccessor:
@@ -60,7 +65,6 @@ class ConfigAccessor:
         return self._config
 
     def save(self) -> None:
-        print(self._config)
         with open(new_config_file(), "w") as f:
             json.dump(
                 dataclasses.asdict(self._config),

{geo_activity_playground-0.37.0 → geo_activity_playground-0.38.0}/geo_activity_playground/core/enrichment.py

@@ -120,6 +120,8 @@ def _get_metadata_from_timeseries(timeseries: pd.DataFrame) -> ActivityMeta:
     metadata["start_longitude"] = timeseries["longitude"].iloc[0]
     metadata["end_longitude"] = timeseries["longitude"].iloc[-1]
 
+    metadata["elevation_gain"] = timeseries["elevation_gain_cum"].iloc[-1]
+
     return metadata
 
 
@@ -191,4 +193,11 @@ def _embellish_single_time_series(
         timeseries["x"] = x
         timeseries["y"] = y
 
+    if "altitude" in timeseries.columns:
+        altitude_diff = timeseries["altitude"].diff()
+        altitude_diff = altitude_diff.ewm(span=5, min_periods=5).mean()
+        altitude_diff.loc[altitude_diff.abs() > 30] = 0
+        altitude_diff.loc[altitude_diff < 0] = 0
+        timeseries["elevation_gain_cum"] = altitude_diff.cumsum()
+
     return timeseries

{geo_activity_playground-0.37.0 → geo_activity_playground-0.38.0}/geo_activity_playground/core/meta_search.py

@@ -4,6 +4,7 @@ import re
 import urllib.parse
 from typing import Optional
 
+import dateutil.parser
 import numpy as np
 import pandas as pd
 
@@ -17,6 +18,23 @@ class SearchQuery:
     start_begin: Optional[datetime.date] = None
     start_end: Optional[datetime.date] = None
 
+    def __str__(self) -> str:
+        bits = []
+        if self.name:
+            bits.append(f"name is “{self.name}”")
+        if self.equipment:
+            bits.append(
+                "equipment is "
+                + (" or ".join(f"“{equipment}”" for equipment in self.equipment))
+            )
+        if self.kind:
+            bits.append("kind is " + (" or ".join(f"“{kind}”" for kind in self.kind)))
+        if self.start_begin:
+            bits.append(f"after “{self.start_begin.isoformat()}”")
+        if self.start_end:
+            bits.append(f"until “{self.start_end.isoformat()}”")
+        return " and ".join(bits)
+
     @property
     def active(self) -> bool:
         return (
@@ -27,7 +45,7 @@ class SearchQuery:
             or self.start_end
         )
 
-    def to_jinja(self) -> dict:
+    def to_primitives(self) -> dict:
         return {
             "equipment": self.equipment,
             "kind": self.kind,
@@ -35,9 +53,24 @@ class SearchQuery:
             "name_case_sensitive": self.name_case_sensitive,
             "start_begin": _format_optional_date(self.start_begin),
             "start_end": _format_optional_date(self.start_end),
-            "active": self.active,
         }
 
+    @classmethod
+    def from_primitives(cls, d: dict) -> "SearchQuery":
+        return cls(
+            equipment=d.get("equipment", []),
+            kind=d.get("kind", []),
+            name=d.get("name", None),
+            name_case_sensitive=d.get("name_case_sensitive", False),
+            start_begin=_parse_date_or_none(d.get("start_begin", None)),
+            start_end=_parse_date_or_none(d.get("start_end", None)),
+        )
+
+    def to_jinja(self) -> dict:
+        result = self.to_primitives()
+        result["active"] = self.active
+        return result
+
     def to_url_str(self) -> str:
         variables = []
         for equipment in self.equipment:
@@ -58,13 +91,6 @@ class SearchQuery:
         )
 
 
-def _format_optional_date(date: Optional[datetime.date]) -> str:
-    if date is None:
-        return ""
-    else:
-        return date.isoformat()
-
-
 def apply_search_query(
     activity_meta: pd.DataFrame, search_query: SearchQuery
 ) -> pd.DataFrame:
@@ -100,6 +126,13 @@ def apply_search_query(
     return activity_meta.loc[mask]
 
 
+def _format_optional_date(date: Optional[datetime.date]) -> str:
+    if date is None:
+        return ""
+    else:
+        return date.isoformat()
+
+
 def _make_mask(
     index: pd.Index,
     default: bool,
@@ -115,3 +148,10 @@ def _filter_column(column: pd.Series, values: list):
     for equipment in values:
         sub_mask |= column == equipment
     return sub_mask
+
+
+def _parse_date_or_none(s: Optional[str]) -> Optional[datetime.date]:
+    if not s:
+        return None
+    else:
+        return dateutil.parser.parse(s).date()

{geo_activity_playground-0.37.0 → geo_activity_playground-0.38.0}/geo_activity_playground/core/summary_stats.py

@@ -27,4 +27,4 @@ def get_equipment_use_table(
     result["first_use"] = [date.date().isoformat() for date in result["first_use"]]
     result["last_use"] = [date.date().isoformat() for date in result["last_use"]]
 
-    return result.reset_index().to_dict(orient="records")
+    return result.reset_index()

{geo_activity_playground-0.37.0 → geo_activity_playground-0.38.0}/geo_activity_playground/core/test_meta_search.py

@@ -89,3 +89,12 @@ def test_make_mask() -> None:
     index = [1, 2]
     assert (_make_mask(index, True) == pd.Series([True, True], index=index)).all()
     assert (_make_mask(index, False) == pd.Series([False, False], index=index)).all()
+
+
+def test_search_query_from_primitives() -> None:
+    search_query = SearchQuery.from_primitives(
+        {"start_end": "2025-01-04", "equipment": ["A", "B"]}
+    )
+    assert search_query.start_end == datetime.date(2025, 1, 4)
+    assert search_query.equipment == ["A", "B"]
+    assert search_query.kind == []

{geo_activity_playground-0.37.0 → geo_activity_playground-0.38.0}/geo_activity_playground/webui/activity/controller.py

@@ -108,6 +108,8 @@ class ActivityController:
             result["heart_zones_plot"] = heart_rate_zone_plot(heart_zones)
         if "altitude" in time_series.columns:
             result["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)
         if "heartrate" in time_series.columns:
             result["heartrate_time_plot"] = heart_rate_time_plot(time_series)
         if "cadence" in time_series.columns:
@@ -323,6 +325,24 @@ def altitude_time_plot(time_series: pd.DataFrame) -> str:
     )
 
 
+def elevation_gain_cum_plot(time_series: pd.DataFrame) -> str:
+    return (
+        alt.Chart(time_series, title="Altitude Gain")
+        .mark_line()
+        .encode(
+            alt.X("time", title="Time"),
+            alt.Y(
+                "elevation_gain_cum",
+                scale=alt.Scale(zero=False),
+                title="Altitude gain / m",
+            ),
+            alt.Color("segment_id:N", title="Segment"),
+        )
+        .interactive(bind_y=False)
+        .to_json(format="vega")
+    )
+
+
 def heart_rate_time_plot(time_series: pd.DataFrame) -> str:
     return (
         alt.Chart(time_series, title="Heart Rate")

{geo_activity_playground-0.37.0 → geo_activity_playground-0.38.0}/geo_activity_playground/webui/activity/templates/activity/day.html.j2

@@ -9,7 +9,7 @@
 
 
 <div class="row mb-3">
-    <div class="col-md-9">
+    <div class="col-12">
         <div id="activity-map" style="height: 500px;"></div>
         <script>
             var map = L.map('activity-map', {
@@ -26,15 +26,6 @@
             map.fitBounds(geojson.getBounds());
         </script>
     </div>
-    <div class="col-md-3">
-        <ol>
-            {% for activity in activities %}
-            <li><span style="color: {{ activity['color'] }};">█</span> <a
-                    href="{{ url_for('.show', id=activity.id) }}">{{
-                    activity.name }}</a></li>
-            {% endfor %}
-        </ol>
-    </div>
 </div>
 
 <div class="row mb-3">
@@ -48,6 +39,7 @@
                     <th>Date</th>
                     <th>Distance / km</th>
                     <th>Elapsed time</th>
+                    <th>Speed / km/h</th>
                     <th>Equipment</th>
                     <th>Kind</th>
                 </tr>
@@ -61,6 +53,7 @@
                     <td>{{ activity.start|dt }}</td>
                     <td>{{ activity.distance_km | round(1) }}</td>
                     <td>{{ activity.elapsed_time|td }}</td>
+                    <td>{{ activity.average_speed_moving_kmh|round(1) }}</td>
                     <td>{{ activity["equipment"] }}</td>
                     <td>{{ activity["kind"] }}</td>
                 </tr>

{geo_activity_playground-0.37.0 → geo_activity_playground-0.38.0}/geo_activity_playground/webui/activity/templates/activity/name.html.j2

@@ -57,6 +57,7 @@
                     <th>Date</th>
                     <th class="numeric-sort">Distance / km</th>
                     <th>Elapsed time</th>
+                    <th>Speed / km/h</th>
                     <th>Equipment</th>
                     <th>Kind</th>
                 </tr>
@@ -70,6 +71,7 @@
                     <td>{{ activity.start|dt }}</td>
                     <td>{{ activity.distance_km | round(1) }}</td>
                     <td>{{ activity.elapsed_time|td }}</td>
+                    <td>{{ activity.average_speed_moving_kmh|round(1) }}</td>
                     <td>{{ activity["equipment"] }}</td>
                     <td>{{ activity["kind"] }}</td>
                 </tr>

{geo_activity_playground-0.37.0 → geo_activity_playground-0.38.0}/geo_activity_playground/webui/activity/templates/activity/show.html.j2

@@ -22,6 +22,12 @@
             <dd>{{ activity.elapsed_time|td }}</dd>
             <dt>Moving time</dt>
             <dd>{{ activity.moving_time|td }}</dd>
+            <dt>Average moving speed</dt>
+            <dd>{{ activity.average_speed_moving_kmh|round(1) }} km/h = {{
+                (60/activity.average_speed_moving_kmh)|round(1) }} min/km</dd>
+            <dt>Average elapsed speed</dt>
+            <dd>{{ activity.average_speed_elapsed_kmh|round(1) }} km/h = {{
+                (60/activity.average_speed_elapsed_kmh)|round(1) }} min/km</dd>
             <dt>Start time</dt>
             <dd><a href="{{ url_for('activity.day', year=date.year, month=date.month, day=date.day) }}">{{ date }}</a>
                 {{ time }}
@@ -30,6 +36,10 @@
             <dd>{{ activity.calories }}</dd>
             <dt>Steps</dt>
             <dd>{{ activity.steps }}</dd>
+            {% if activity.elevation_gain is defined %}
+            <dt>Elevation gain</dt>
+            <dd>{{ activity.elevation_gain|round(0) }} m</dd>
+            {% endif %}
             <dt>Equipment</dt>
             <dd>{{ activity['equipment'] }}</dd>
             <dt>New Explorer Tiles</dt>
@@ -100,6 +110,7 @@
     </div>
 </div>
 
+{% if altitude_time_plot is defined %}
 <div class="row mb-3">
     <div class="col">
         <h2>Altitude</h2>
@@ -110,7 +121,13 @@
     <div class="col-md-4">
         {{ vega_direct("altitude_time_plot", altitude_time_plot) }}
     </div>
+    {% if elevation_gain_cum_plot is defined %}
+    <div class="col-md-4">
+        {{ vega_direct("elevation_gain_cum_plot", elevation_gain_cum_plot) }}
+    </div>
+    {% endif %}
 </div>
+{% endif %}
 
 {% if heartrate_time_plot is defined %}
 <h2>Heart rate</h2>

{geo_activity_playground-0.37.0 → geo_activity_playground-0.38.0}/geo_activity_playground/webui/app.py

@@ -8,6 +8,7 @@ import urllib.parse
 
 from flask import Flask
 from flask import render_template
+from flask import request
 
 from ..core.activities import ActivityRepository
 from ..core.config import Config
@@ -31,6 +32,7 @@ from .square_planner_blueprint import make_square_planner_blueprint
 from .summary_blueprint import make_summary_blueprint
 from .tile_blueprint import make_tile_blueprint
 from .upload_blueprint import make_upload_blueprint
+from geo_activity_playground.webui.search_util import SearchQueryHistory
 
 
 def route_start(app: Flask, repository: ActivityRepository, config: Config) -> None:
@@ -79,6 +81,7 @@ def web_ui_main(
         return f"{h}:{m:02d}:{s:02d}"
 
     authenticator = Authenticator(config_accessor())
+    search_query_history = SearchQueryHistory(config_accessor, authenticator)
 
     config = config_accessor()
     activity_controller = ActivityController(repository, tile_visit_accessor, config)
@@ -98,16 +101,20 @@ def web_ui_main(
         make_calendar_blueprint(calendar_controller), url_prefix="/calendar"
     )
     app.register_blueprint(
-        make_eddington_blueprint(repository), url_prefix="/eddington"
+        make_eddington_blueprint(repository, search_query_history),
+        url_prefix="/eddington",
     )
     app.register_blueprint(
         make_equipment_blueprint(repository, config), url_prefix="/equipment"
     )
     app.register_blueprint(
-        make_explorer_blueprint(explorer_controller), url_prefix="/explorer"
+        make_explorer_blueprint(explorer_controller, authenticator),
+        url_prefix="/explorer",
     )
     app.register_blueprint(
-        make_heatmap_blueprint(repository, tile_visit_accessor, config_accessor()),
+        make_heatmap_blueprint(
+            repository, tile_visit_accessor, config_accessor(), search_query_history
+        ),
         url_prefix="/heatmap",
     )
     app.register_blueprint(
@@ -119,11 +126,14 @@ def web_ui_main(
         url_prefix="/square-planner",
     )
     app.register_blueprint(
-        make_search_blueprint(repository),
+        make_search_blueprint(
+            repository, search_query_history, authenticator, config_accessor
+        ),
         url_prefix="/search",
     )
     app.register_blueprint(
-        make_summary_blueprint(repository, config), url_prefix="/summary"
+        make_summary_blueprint(repository, config, search_query_history),
+        url_prefix="/summary",
     )
 
     app.register_blueprint(make_tile_blueprint(config), url_prefix="/tile")
@@ -148,6 +158,9 @@ def web_ui_main(
             "version": _try_get_version(),
             "num_activities": len(repository),
             "map_tile_attribution": config_accessor().map_tile_attribution,
+            "search_query_favorites": search_query_history.prepare_favorites(),
+            "search_query_last": search_query_history.prepare_last(),
+            "request_url": urllib.parse.quote_plus(request.url),
         }
         if len(repository):
             variables["equipments_avail"] = sorted(

geo_activity_playground-0.38.0/geo_activity_playground/webui/eddington_blueprint.py

@@ -0,0 +1,190 @@
+import datetime
+
+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 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
+
+
+def make_eddington_blueprint(
+    repository: ActivityRepository, search_query_history: SearchQueryHistory
+) -> Blueprint:
+    blueprint = Blueprint("eddington", __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)
+            .dropna(subset=["start", "distance_km"])
+            .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_distances_per_group(
+            activities.groupby("date")
+        )
+        en_per_week, eddington_df_per_week = _get_distances_per_group(
+            activities.groupby(["isoyear", "isoweek"])
+        )
+
+        return render_template(
+            "eddington/index.html.j2",
+            eddington_number=en_per_day,
+            logarithmic_plot=_make_eddington_plot(
+                eddington_df_per_day, en_per_day, "Days"
+            ),
+            eddington_per_week=en_per_week,
+            eddington_per_week_plot=_make_eddington_plot(
+                eddington_df_per_week, en_per_week, "Weeks"
+            ),
+            eddington_table=eddington_df_per_day.loc[
+                (eddington_df_per_day["distance_km"] > en_per_day)
+                & (eddington_df_per_day["distance_km"] <= en_per_day + 10)
+            ].to_dict(orient="records"),
+            eddington_table_weeks=eddington_df_per_week.loc[
+                (eddington_df_per_week["distance_km"] > en_per_week)
+                & (eddington_df_per_week["distance_km"] <= en_per_week + 10)
+            ].to_dict(orient="records"),
+            query=query.to_jinja(),
+            yearly_eddington=_get_yearly_eddington(activities),
+            eddington_number_history_plot=_get_eddington_number_history(activities),
+        )
+
+    return blueprint
+
+
+def _get_distances_per_group(grouped) -> tuple[int, pd.DataFrame]:
+    sum_per_group = grouped.apply(
+        lambda group: int(sum(group["distance_km"])), include_groups=False
+    )
+    counts = dict(zip(*np.unique(sorted(sum_per_group), return_counts=True)))
+    eddington = pd.DataFrame(
+        {"distance_km": d, "count": counts.get(d, 0)}
+        for d in range(max(counts.keys()) + 1)
+    )
+    eddington["total"] = eddington["count"][::-1].cumsum()[::-1]
+    en = eddington.loc[eddington["total"] >= eddington["distance_km"]][
+        "distance_km"
+    ].iloc[-1]
+    eddington["missing"] = eddington["distance_km"] - eddington["total"]
+    return en, eddington
+
+
+def _make_eddington_plot(eddington_df: pd.DataFrame, en: int, interval: str) -> dict:
+    x = list(range(1, max(eddington_df["distance_km"]) + 1))
+    return (
+        (
+            (
+                alt.Chart(
+                    eddington_df,
+                    height=500,
+                    width=800,
+                    title=f"Eddington Number {en}",
+                )
+                .mark_area(interpolate="step")
+                .encode(
+                    alt.X(
+                        "distance_km",
+                        scale=alt.Scale(domainMin=0),
+                        title="Distance / km",
+                    ),
+                    alt.Y(
+                        "total",
+                        scale=alt.Scale(domainMax=en + 10),
+                        title=f"{interval} exceeding distance",
+                    ),
+                    [
+                        alt.Tooltip("distance_km", title="Distance / km"),
+                        alt.Tooltip("total", title=f"{interval} exceeding distance"),
+                        alt.Tooltip("missing", title=f"{interval} missing for next"),
+                    ],
+                )
+            )
+            + (
+                alt.Chart(pd.DataFrame({"distance_km": x, "total": x}))
+                .mark_line(color="red")
+                .encode(alt.X("distance_km"), alt.Y("total"))
+            )
+        )
+        .interactive(bind_x=False)
+        .to_json(format="vega")
+    )
+
+
+def _get_eddington_number(distances: pd.Series) -> int:
+    if len(distances) == 1:
+        if distances.iloc[0] >= 1:
+            return 1
+        else:
+            0
+
+    sorted_distances = sorted(distances, reverse=True)
+    for en, distance in enumerate(sorted_distances, 1):
+        if distance < en:
+            return en - 1
+
+
+def _get_yearly_eddington(meta: pd.DataFrame) -> dict[int, int]:
+    meta = meta.dropna(subset=["start", "distance_km"]).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["distance_km"].sum()), include_groups=False
+            )
+        ),
+        include_groups=False,
+    )
+    return yearly_eddington.to_dict()
+
+
+def _get_eddington_number_history(meta: pd.DataFrame) -> dict:
+
+    daily_distances = meta.groupby("date").apply(
+        lambda group2: int(group2["distance_km"].sum()), include_groups=False
+    )
+
+    eddington_number_history = {"date": [], "eddington_number": []}
+    top_days = []
+    for date, distance in daily_distances.items():
+        if len(top_days) == 0:
+            top_days.append(distance)
+        else:
+            if distance >= top_days[0]:
+                top_days.append(distance)
+                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))
+    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-0.37.0 → geo_activity_playground-0.38.0}/geo_activity_playground/webui/equipment_blueprint.py

@@ -6,6 +6,7 @@ from flask import render_template
 from geo_activity_playground.core.activities import ActivityRepository
 from geo_activity_playground.core.config import Config
 from geo_activity_playground.core.summary_stats import get_equipment_use_table
+from geo_activity_playground.webui.plot_util import make_kind_scale
 
 
 def make_equipment_blueprint(
@@ -20,7 +21,7 @@ def make_equipment_blueprint(
         )
 
         equipment_variables = {}
-        for equipment in repository.meta["equipment"].unique():
+        for equipment in equipment_summary["equipment"]:
             selection = repository.meta.loc[repository.meta["equipment"] == equipment]
             total_distances = pd.DataFrame(
                 {
@@ -55,6 +56,11 @@ def make_equipment_blueprint(
                 .encode(
                     alt.X("year(start):O", title="Year"),
                     alt.Y("sum(distance_km)", title="Distance / km"),
+                    alt.Color(
+                        "kind",
+                        scale=make_kind_scale(repository.meta, config),
+                        title="Kind",
+                    ),
                 )
                 .to_json(format="vega")
             )
@@ -67,7 +73,10 @@ def make_equipment_blueprint(
                 )
                 .mark_bar()
                 .encode(
-                    alt.X("kind", title="Kind"),
+                    alt.X(
+                        "kind",
+                        title="Kind",
+                    ),
                     alt.Y("sum(distance_km)", title="Distance / km"),
                 )
                 .to_json(format="vega")
@@ -84,7 +93,7 @@ def make_equipment_blueprint(
 
         variables = {
             "equipment_variables": equipment_variables,
-            "equipment_summary": equipment_summary,
+            "equipment_summary": equipment_summary.to_dict(orient="records"),
         }
 
         return render_template("equipment/index.html.j2", **variables)