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

geo_activity_playground/core/meta_search.py

@@ -0,0 +1,117 @@
+import dataclasses
+import datetime
+import re
+import urllib.parse
+from typing import Optional
+
+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
+
+    @property
+    def active(self) -> bool:
+        return (
+            self.equipment
+            or self.kind
+            or self.name
+            or self.start_begin
+            or self.start_end
+        )
+
+    def to_jinja(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),
+            "active": self.active,
+        }
+
+    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 _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:
+    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 _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

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().to_dict(orient="records")

geo_activity_playground/core/test_meta_search.py

@@ -0,0 +1,91 @@
+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()

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/app.py

@@ -21,8 +21,7 @@ from .calendar.blueprint import make_calendar_blueprint
 from .calendar.controller import CalendarController
 from .eddington_blueprint import make_eddington_blueprint
 from .entry_controller import EntryController
-from .equipment.blueprint import make_equipment_blueprint
-from .equipment.controller import EquipmentController
+from .equipment_blueprint import make_equipment_blueprint
 from .explorer.blueprint import make_explorer_blueprint
 from .explorer.controller import ExplorerController
 from .heatmap.blueprint import make_heatmap_blueprint
@@ -84,7 +83,6 @@ def web_ui_main(
     config = config_accessor()
     activity_controller = ActivityController(repository, tile_visit_accessor, config)
     calendar_controller = CalendarController(repository)
-    equipment_controller = EquipmentController(repository, config)
     explorer_controller = ExplorerController(
         repository, tile_visit_accessor, config_accessor
     )
@@ -103,7 +101,7 @@ def web_ui_main(
         make_eddington_blueprint(repository), url_prefix="/eddington"
     )
     app.register_blueprint(
-        make_equipment_blueprint(equipment_controller), url_prefix="/equipment"
+        make_equipment_blueprint(repository, config), url_prefix="/equipment"
     )
     app.register_blueprint(
         make_explorer_blueprint(explorer_controller), url_prefix="/explorer"
@@ -146,11 +144,17 @@ def web_ui_main(
 
     @app.context_processor
     def inject_global_variables() -> dict:
-        return {
+        variables = {
             "version": _try_get_version(),
             "num_activities": len(repository),
             "map_tile_attribution": config_accessor().map_tile_attribution,
         }
+        if len(repository):
+            variables["equipments_avail"] = sorted(
+                repository.meta["equipment"].unique()
+            )
+            variables["kinds_avail"] = sorted(repository.meta["kind"].unique())
+        return variables
 
     app.run(host=host, port=port)
 

geo_activity_playground/webui/eddington_blueprint.py

@@ -3,8 +3,11 @@ 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
 
 
 def make_eddington_blueprint(repository: ActivityRepository) -> Blueprint:
@@ -12,9 +15,10 @@ def make_eddington_blueprint(repository: ActivityRepository) -> Blueprint:
 
     @blueprint.route("/")
     def index():
-        activities = repository.meta.loc[
-            repository.meta["consider_for_achievements"]
-        ].copy()
+        query = search_query_from_form(request.args)
+        activities = apply_search_query(repository.meta, query)
+        activities = activities.loc[activities["consider_for_achievements"]].copy()
+
         activities["day"] = [start.date() for start in activities["start"]]
 
         sum_per_day = activities.groupby("day").apply(
@@ -76,6 +80,7 @@ def make_eddington_blueprint(repository: ActivityRepository) -> Blueprint:
             eddington_table=eddington.loc[
                 (eddington["distance_km"] > en) & (eddington["distance_km"] <= en + 10)
             ].to_dict(orient="records"),
+            query=query.to_jinja(),
         )
 
     return blueprint

geo_activity_playground/webui/{equipment/controller.py → equipment_blueprint.py}

@@ -1,47 +1,27 @@
 import altair as alt
 import pandas as pd
+from flask import Blueprint
+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
 
 
-class EquipmentController:
-    def __init__(self, repository: ActivityRepository, config: Config) -> None:
-        self._repository = repository
-        self._config = config
+def make_equipment_blueprint(
+    repository: ActivityRepository, config: Config
+) -> Blueprint:
+    blueprint = Blueprint("equipment", __name__, template_folder="templates")
 
-    def render(self) -> dict:
-        kind_per_equipment = self._repository.meta.groupby("equipment").apply(
-            lambda group: group.groupby("kind")
-            .apply(lambda group2: sum(group2["distance_km"]), include_groups=False)
-            .idxmax(),
-            include_groups=False,
+    @blueprint.route("/")
+    def index():
+        equipment_summary = get_equipment_use_table(
+            repository.meta, config.equipment_offsets
         )
 
-        equipment_summary = (
-            self._repository.meta.groupby("equipment")
-            .apply(
-                lambda group: pd.Series(
-                    {
-                        "total_distance_km": group["distance_km"].sum(),
-                        "first_use": group["start"].iloc[0],
-                        "last_use": group["start"].iloc[-1],
-                    },
-                ),
-                include_groups=False,
-            )
-            .sort_values("last_use", ascending=False)
-        )
-
-        equipment_summary["primarily_used_for"] = None
-        for equipment, kind in kind_per_equipment.items():
-            equipment_summary.loc[equipment, "primarily_used_for"] = kind
-
         equipment_variables = {}
-        for equipment in equipment_summary.index:
-            selection = self._repository.meta.loc[
-                self._repository.meta["equipment"] == equipment
-            ]
+        for equipment in repository.meta["equipment"].unique():
+            selection = repository.meta.loc[repository.meta["equipment"] == equipment]
             total_distances = pd.DataFrame(
                 {
                     "time": selection["start"],
@@ -102,13 +82,11 @@ class EquipmentController:
                 "usages_plot_id": f"usages_plot_{hash(equipment)}",
             }
 
-        for equipment, offset in self._config.equipment_offsets.items():
-            if equipment in equipment_summary.index:
-                equipment_summary.loc[equipment, "total_distance_km"] += offset
-
-        return {
+        variables = {
             "equipment_variables": equipment_variables,
-            "equipment_summary": equipment_summary.reset_index().to_dict(
-                orient="records"
-            ),
+            "equipment_summary": equipment_summary,
         }
+
+        return render_template("equipment/index.html.j2", **variables)
+
+    return blueprint

geo_activity_playground/webui/heatmap/blueprint.py

@@ -8,6 +8,7 @@ from geo_activity_playground.core.activities import ActivityRepository
 from geo_activity_playground.core.config import Config
 from geo_activity_playground.explorer.tile_visits import TileVisitAccessor
 from geo_activity_playground.webui.heatmap.heatmap_controller import HeatmapController
+from geo_activity_playground.webui.search_util import search_query_from_form
 
 
 def make_heatmap_blueprint(
@@ -20,30 +21,16 @@ def make_heatmap_blueprint(
 
     @blueprint.route("/")
     def index():
+        query = search_query_from_form(request.args)
         return render_template(
-            "heatmap/index.html.j2",
-            **heatmap_controller.render(
-                [int(k) for k in request.args.getlist("kind")],
-                request.args.get(
-                    "date-start", type=dateutil.parser.parse, default=None
-                ),
-                request.args.get("date-end", type=dateutil.parser.parse, default=None),
-            )
+            "heatmap/index.html.j2", **heatmap_controller.render(query)
         )
 
     @blueprint.route("/tile/<int:z>/<int:x>/<int:y>.png")
     def tile(x: int, y: int, z: int):
+        query = search_query_from_form(request.args)
         return Response(
-            heatmap_controller.render_tile(
-                x,
-                y,
-                z,
-                [int(k) for k in request.args.getlist("kind")],
-                request.args.get(
-                    "date-start", type=dateutil.parser.parse, default=None
-                ),
-                request.args.get("date-end", type=dateutil.parser.parse, default=None),
-            ),
+            heatmap_controller.render_tile(x, y, z, query),
             mimetype="image/png",
         )
 
@@ -51,18 +38,9 @@ def make_heatmap_blueprint(
         "/download/<float:north>/<float:east>/<float:south>/<float:west>/heatmap.png"
     )
     def download(north: float, east: float, south: float, west: float):
+        query = search_query_from_form(request.args)
         return Response(
-            heatmap_controller.download_heatmap(
-                north,
-                east,
-                south,
-                west,
-                [int(k) for k in request.args.getlist("kind")],
-                request.args.get(
-                    "date-start", type=dateutil.parser.parse, default=None
-                ),
-                request.args.get("date-end", type=dateutil.parser.parse, default=None),
-            ),
+            heatmap_controller.download_heatmap(north, east, south, west, query),
             mimetype="image/png",
             headers={"Content-disposition": 'attachment; filename="heatmap.png"'},
         )