geo-activity-playground 0.36.2__py3-none-any.whl → 0.38.0__py3-none-any.whl

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/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/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/core/meta_search.py

@@ -0,0 +1,157 @@
+import dataclasses
+import datetime
+import re
+import urllib.parse
+from typing import Optional
+
+import dateutil.parser
+import numpy as np
+import pandas as pd
+
+
+@dataclasses.dataclass
+class SearchQuery:
+    equipment: list[str] = dataclasses.field(default_factory=list)
+    kind: list[str] = dataclasses.field(default_factory=list)
+    name: Optional[str] = None
+    name_case_sensitive: bool = False
+    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 (
+            self.equipment
+            or self.kind
+            or self.name
+            or self.start_begin
+            or self.start_end
+        )
+
+    def to_primitives(self) -> dict:
+        return {
+            "equipment": self.equipment,
+            "kind": self.kind,
+            "name": self.name or "",
+            "name_case_sensitive": self.name_case_sensitive,
+            "start_begin": _format_optional_date(self.start_begin),
+            "start_end": _format_optional_date(self.start_end),
+        }
+
+    @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:
+            variables.append(("equipment", equipment))
+        for kind in self.kind:
+            variables.append(("kind", kind))
+        if self.name:
+            variables.append(("name", self.name))
+        if self.name_case_sensitive:
+            variables.append(("name_case_sensitive", "true"))
+        if self.start_begin:
+            variables.append(("start_begin", self.start_begin.isoformat()))
+        if self.start_end:
+            variables.append(("start_end", self.start_end.isoformat()))
+
+        return "&".join(
+            f"{key}={urllib.parse.quote_plus(value)}" for key, value in variables
+        )
+
+
+def apply_search_query(
+    activity_meta: pd.DataFrame, search_query: SearchQuery
+) -> pd.DataFrame:
+    mask = _make_mask(activity_meta.index, True)
+
+    if search_query.equipment:
+        mask &= _filter_column(activity_meta["equipment"], search_query.equipment)
+    if search_query.kind:
+        mask &= _filter_column(activity_meta["kind"], search_query.kind)
+    if search_query.name:
+        mask &= pd.Series(
+            [
+                bool(
+                    re.search(
+                        search_query.name,
+                        activity_name,
+                        0 if search_query.name_case_sensitive else re.IGNORECASE,
+                    )
+                )
+                for activity_name in activity_meta["name"]
+            ],
+            index=activity_meta.index,
+        )
+    if search_query.start_begin is not None:
+        start_begin = datetime.datetime.combine(
+            search_query.start_begin, datetime.time.min
+        )
+        mask &= start_begin <= activity_meta["start"]
+    if search_query.start_end is not None:
+        start_end = datetime.datetime.combine(search_query.start_end, datetime.time.max)
+        mask &= activity_meta["start"] <= start_end
+
+    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,
+) -> pd.Series:
+    if default:
+        return pd.Series(np.ones((len(index),), dtype=np.bool), index=index)
+    else:
+        return pd.Series(np.zeros((len(index),), dtype=np.bool), index=index)
+
+
+def _filter_column(column: pd.Series, values: list):
+    sub_mask = _make_mask(column.index, False)
+    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/core/summary_stats.py

@@ -0,0 +1,30 @@
+import pandas as pd
+
+
+def get_equipment_use_table(
+    activity_meta: pd.DataFrame, offsets: dict[str, float]
+) -> pd.DataFrame:
+    result = (
+        activity_meta.groupby("equipment")
+        .apply(
+            lambda group: pd.Series(
+                {
+                    "total_distance_km": group["distance_km"].sum(),
+                    "first_use": group["start"].min(skipna=True),
+                    "last_use": group["start"].max(skipna=True),
+                },
+            ),
+            include_groups=False,
+        )
+        .sort_values("last_use", ascending=False)
+    )
+    for equipment, offset in offsets.items():
+        result.loc[equipment, "total_distance_km"] += offset
+
+    result["total_distance_km"] = [
+        int(round(elem)) for elem in result["total_distance_km"]
+    ]
+    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()

geo_activity_playground/core/test_meta_search.py

@@ -0,0 +1,100 @@
+import datetime
+
+import pandas as pd
+
+from geo_activity_playground.core.meta_search import _make_mask
+from geo_activity_playground.core.meta_search import apply_search_query
+from geo_activity_playground.core.meta_search import SearchQuery
+
+
+def test_empty_query() -> None:
+    activity_meta = pd.DataFrame(
+        {
+            "equipment": pd.Series(["A", "B", "B"]),
+            "id": pd.Series([1, 2, 3]),
+            "kind": pd.Series(["X", "X", "Y"]),
+            "name": ["Test1", "Test2", "Test3"],
+            "start": [
+                datetime.datetime(2024, 12, 24, 10),
+                datetime.datetime(2025, 1, 1, 10),
+                None,
+            ],
+        }
+    )
+
+    search_query = SearchQuery()
+
+    actual = apply_search_query(activity_meta, search_query)
+    assert (actual["id"] == activity_meta["id"]).all()
+
+
+def test_equipment_query() -> None:
+    activity_meta = pd.DataFrame(
+        {
+            "equipment": pd.Series(["A", "B", "B"]),
+            "id": pd.Series([1, 2, 3]),
+            "kind": pd.Series(["X", "X", "Y"]),
+            "name": ["Test1", "Test2", "Test3"],
+            "start": [
+                datetime.datetime(2024, 12, 24, 10),
+                datetime.datetime(2025, 1, 1, 10),
+                None,
+            ],
+        }
+    )
+    search_query = SearchQuery(equipment=["B"])
+    actual = apply_search_query(activity_meta, search_query)
+    assert set(actual["id"]) == {2, 3}
+
+
+def test_date_query() -> None:
+    activity_meta = pd.DataFrame(
+        {
+            "equipment": pd.Series(["A", "B", "B"]),
+            "id": pd.Series([1, 2, 3]),
+            "kind": pd.Series(["X", "X", "Y"]),
+            "name": ["Test1", "Test2", "Test3"],
+            "start": [
+                datetime.datetime(2024, 12, 24, 10),
+                datetime.datetime(2025, 1, 1, 10),
+                None,
+            ],
+        }
+    )
+    search_query = SearchQuery(start_begin=datetime.date(2024, 12, 31))
+    actual = apply_search_query(activity_meta, search_query)
+    assert set(actual["id"]) == {2}
+
+
+def test_name_query() -> None:
+    activity_meta = pd.DataFrame(
+        {
+            "equipment": pd.Series(["A", "B", "B"]),
+            "id": pd.Series([1, 2, 3]),
+            "kind": pd.Series(["X", "X", "Y"]),
+            "name": ["Test1", "Test2", "Test3"],
+            "start": [
+                datetime.datetime(2024, 12, 24, 10),
+                datetime.datetime(2025, 1, 1, 10),
+                None,
+            ],
+        }
+    )
+    search_query = SearchQuery(name="Test1")
+    actual = apply_search_query(activity_meta, search_query)
+    assert set(actual["id"]) == {1}
+
+
+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/core/test_summary_stats.py

@@ -0,0 +1,108 @@
+import datetime
+
+import pandas as pd
+import pytest
+
+from geo_activity_playground.core.summary_stats import get_equipment_use_table
+
+
+@pytest.fixture
+def activity_meta() -> pd.DataFrame:
+    """
+    calories: float
+    commute: bool
+    consider_for_achievements: bool
+    distance_km: float
+    elapsed_time: datetime.timedelta
+    end_latitude: float
+    end_longitude: float
+    equipment: str
+    id: int
+    kind: str
+    moving_time: datetime.timedelta
+    name: str
+    path: str
+    start_latitude: float
+    start_longitude: float
+    start: np.datetime64
+    steps: int
+    """
+    return pd.DataFrame(
+        {
+            "calories": pd.Series([None, 1000, 2000]),
+            "commute": pd.Series([True, False, True]),
+            "consider_for_achievements": pd.Series([True, True, False]),
+            "distance_km": pd.Series([9.8, 4.4, 4.3]),
+            "elapsed_time": pd.Series(
+                [
+                    datetime.timedelta(minutes=0.34),
+                    datetime.timedelta(minutes=0.67),
+                    None,
+                ]
+            ),
+            "end_latitude": pd.Series([0.58, 0.5, 0.19]),
+            "end_longitude": pd.Series([0.2, 0.94, 0.69]),
+            "equipment": pd.Series(["A", "B", "B"]),
+            "id": pd.Series([1, 2, 3]),
+            "kind": pd.Series(["X", "X", "Y"]),
+            "moving_time": pd.Series(
+                [
+                    datetime.timedelta(minutes=0.32),
+                    datetime.timedelta(minutes=0.83),
+                    None,
+                ]
+            ),
+            "name": pd.Series(["Test1", "Test2", "Test1"]),
+            "path": pd.Series(["Test1.fit", "Test2.gpx", "Test1.kml"]),
+            "start_latitude": pd.Series([0.22, 0.02, 0.35]),
+            "start_longitude": pd.Series([0.95, 0.95, 0.81]),
+            "start": pd.Series(
+                [
+                    datetime.datetime(2024, 12, 24, 10),
+                    datetime.datetime(2025, 1, 1, 10),
+                    None,
+                ]
+            ),
+            "steps": pd.Series([1234, None, 5432]),
+        }
+    )
+
+
+def test_activity_meta(activity_meta) -> None:
+    print()
+    print(activity_meta)
+
+
+def test_equipment_use_table(activity_meta) -> None:
+    activity_meta = pd.DataFrame(
+        {
+            "distance_km": pd.Series([9.8, 4.4, 4.3]),
+            "equipment": pd.Series(["A", "B", "B"]),
+            "start": pd.Series(
+                [
+                    datetime.datetime(2024, 12, 24, 10),
+                    datetime.datetime(2025, 1, 1, 10),
+                    None,
+                ]
+            ),
+        }
+    )
+
+    offsets = {"A": 4.0}
+
+    expected = [
+        {
+            "equipment": "B",
+            "total_distance_km": 9,
+            "first_use": "2025-01-01",
+            "last_use": "2025-01-01",
+        },
+        {
+            "equipment": "A",
+            "total_distance_km": 14,
+            "first_use": "2024-12-24",
+            "last_use": "2024-12-24",
+        },
+    ]
+    actual = get_equipment_use_table(activity_meta, offsets)
+    assert actual == expected

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/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/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/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>