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

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
@@ -21,8 +22,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
@@ -32,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:
@@ -80,11 +81,11 @@ 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)
     calendar_controller = CalendarController(repository)
-    equipment_controller = EquipmentController(repository, config)
     explorer_controller = ExplorerController(
         repository, tile_visit_accessor, config_accessor
     )
@@ -100,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(equipment_controller), url_prefix="/equipment"
+        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(
@@ -121,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")
@@ -146,11 +154,20 @@ 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,
+            "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(
+                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

@@ -1,81 +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) -> Blueprint:
+def make_eddington_blueprint(
+    repository: ActivityRepository, search_query_history: SearchQueryHistory
+) -> Blueprint:
     blueprint = Blueprint("eddington", __name__, template_folder="templates")
 
     @blueprint.route("/")
     def index():
-        activities = repository.meta.loc[
-            repository.meta["consider_for_achievements"]
-        ].copy()
-        activities["day"] = [start.date() for start in activities["start"]]
+        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()
+        )
 
-        sum_per_day = activities.groupby("day").apply(
-            lambda group: int(sum(group["distance_km"])), include_groups=False
+        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"])
         )
-        counts = dict(zip(*np.unique(sorted(sum_per_day), return_counts=True)))
-        eddington = pd.DataFrame(
-            {"distance_km": d, "count": counts.get(d, 0)}
-            for d in range(max(counts.keys()) + 1)
+
+        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),
         )
-        eddington["total"] = eddington["count"][::-1].cumsum()[::-1]
-        x = list(range(1, max(eddington["distance_km"]) + 1))
-        en = eddington.loc[eddington["total"] >= eddington["distance_km"]][
-            "distance_km"
-        ].iloc[-1]
-        eddington["missing"] = eddington["distance_km"] - eddington["total"]
-
-        logarithmic_plot = (
+
+    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,
-                        height=500,
-                        width=1000,
-                        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="Days exceeding distance",
-                        ),
-                        [
-                            alt.Tooltip("distance_km", title="Distance / km"),
-                            alt.Tooltip("total", title="Days exceeding distance"),
-                            alt.Tooltip("missing", title="Days missing for next"),
-                        ],
-                    )
+                alt.Chart(
+                    eddington_df,
+                    height=500,
+                    width=800,
+                    title=f"Eddington Number {en}",
                 )
-                + (
-                    alt.Chart(pd.DataFrame({"distance_km": x, "total": x}))
-                    .mark_line(color="red")
-                    .encode(alt.X("distance_km"), alt.Y("total"))
+                .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"),
+                    ],
                 )
             )
-            .interactive()
-            .to_json(format="vega")
+            + (
+                alt.Chart(pd.DataFrame({"distance_km": x, "total": x}))
+                .mark_line(color="red")
+                .encode(alt.X("distance_km"), alt.Y("total"))
+            )
         )
-        return render_template(
-            "eddington/index.html.j2",
-            eddington_number=en,
-            logarithmic_plot=logarithmic_plot,
-            eddington_table=eddington.loc[
-                (eddington["distance_km"] > en) & (eddington["distance_km"] <= en + 10)
-            ].to_dict(orient="records"),
+        .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 blueprint
+    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/webui/{equipment/controller.py → equipment_blueprint.py}

@@ -1,47 +1,28 @@
 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
+from geo_activity_playground.webui.plot_util import make_kind_scale
 
 
-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 equipment_summary["equipment"]:
+            selection = repository.meta.loc[repository.meta["equipment"] == equipment]
             total_distances = pd.DataFrame(
                 {
                     "time": selection["start"],
@@ -75,6 +56,11 @@ class EquipmentController:
                 .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")
             )
@@ -87,7 +73,10 @@ class EquipmentController:
                 )
                 .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")
@@ -102,13 +91,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.to_dict(orient="records"),
         }
+
+        return render_template("equipment/index.html.j2", **variables)
+
+    return blueprint

geo_activity_playground/webui/explorer/blueprint.py

@@ -4,11 +4,14 @@ from flask import render_template
 from flask import Response
 from flask import url_for
 
+from geo_activity_playground.webui.authenticator import Authenticator
+from geo_activity_playground.webui.authenticator import needs_authentication
 from geo_activity_playground.webui.explorer.controller import ExplorerController
 
 
 def make_explorer_blueprint(
     explorer_controller: ExplorerController,
+    authenticator: Authenticator,
 ) -> Blueprint:
     blueprint = Blueprint("explorer", __name__, template_folder="templates")
 
@@ -19,6 +22,7 @@ def make_explorer_blueprint(
         )
 
     @blueprint.route("/enable-zoom-level/<zoom>")
+    @needs_authentication(authenticator)
     def enable_zoom_level(zoom: str):
         explorer_controller.enable_zoom_level(int(zoom))
         return redirect(url_for(".map", zoom=zoom))

geo_activity_playground/webui/heatmap/blueprint.py

@@ -8,42 +8,32 @@ 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
+from geo_activity_playground.webui.search_util import SearchQueryHistory
 
 
 def make_heatmap_blueprint(
     repository: ActivityRepository,
     tile_visit_accessor: TileVisitAccessor,
     config: Config,
+    search_query_history: SearchQueryHistory,
 ) -> Blueprint:
     heatmap_controller = HeatmapController(repository, tile_visit_accessor, config)
     blueprint = Blueprint("heatmap", __name__, template_folder="templates")
 
     @blueprint.route("/")
     def index():
+        query = search_query_from_form(request.args)
+        search_query_history.register_query(query)
         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 +41,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"'},
         )