geo-activity-playground 0.24.1__py3-none-any.whl → 0.25.0__py3-none-any.whl

geo_activity_playground/webui/app.py

@@ -18,11 +18,12 @@ from .explorer.blueprint import make_explorer_blueprint
 from .heatmap.blueprint import make_heatmap_blueprint
 from .search_controller import SearchController
 from .square_planner.blueprint import make_square_planner_blueprint
-from .strava_controller import StravaController
+from .strava.blueprint import make_strava_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.core.privacy_zones import PrivacyZone
+from geo_activity_playground.webui.strava.controller import StravaController
 
 
 def route_search(app: Flask, repository: ActivityRepository) -> None:
@@ -45,35 +46,10 @@ def route_start(app: Flask, repository: ActivityRepository) -> None:
         return render_template("home.html.j2", **entry_controller.render())
 
 
-def route_strava(app: Flask, host: str, port: int) -> None:
-    strava_controller = StravaController()
-
-    @app.route("/strava/connect")
-    def strava_connect():
-        return render_template(
-            "strava-connect.html.j2",
-            host=host,
-            port=port,
-            **strava_controller.action_connect()
-        )
-
-    @app.route("/strava/authorize")
-    def strava_authorize():
-        client_id = request.form["client_id"]
-        client_secret = request.form["client_secret"]
-        return redirect(
-            strava_controller.action_authorize(host, port, client_id, client_secret)
-        )
-
-    @app.route("/strava/callback")
-    def strava_callback():
-        code = request.args.get("code", type=str)
-        return render_template(
-            "strava-connect.html.j2",
-            host=host,
-            port=port,
-            **strava_controller.action_connect()
-        )
+def route_settings(app: Flask) -> None:
+    @app.route("/settings")
+    def settings():
+        return render_template("settings.html.j2")
 
 
 def get_secret_key():
@@ -99,7 +75,7 @@ def webui_main(
 
     route_search(app, repository)
     route_start(app, repository)
-    route_strava(app, host, port)
+    route_settings(app)
 
     app.config["UPLOAD_FOLDER"] = "Activities"
     app.secret_key = get_secret_key()
@@ -136,6 +112,10 @@ def webui_main(
         make_summary_blueprint(repository),
         url_prefix="/summary",
     )
+    app.register_blueprint(
+        make_strava_blueprint(host, port),
+        url_prefix="/strava",
+    )
     app.register_blueprint(make_tile_blueprint(), url_prefix="/tile")
     app.register_blueprint(
         make_upload_blueprint(repository, tile_visit_accessor, config),

geo_activity_playground/webui/entry_controller.py

@@ -13,12 +13,12 @@ class EntryController:
         self._repository = repository
 
     def render(self) -> dict:
-        result = {
-            "distance_last_30_days_plot": distance_last_30_days_meta_plot(
+        result = {"latest_activities": []}
+
+        if len(self._repository):
+            result["distance_last_30_days_plot"] = distance_last_30_days_meta_plot(
                 self._repository.meta
-            ),
-            "latest_activities": [],
-        }
+            )
 
         for activity in itertools.islice(
             self._repository.iter_activities(dropna=True), 15

geo_activity_playground/webui/equipment/controller.py

@@ -10,64 +10,105 @@ class EquipmentController:
         self._repository = repository
 
     def render(self) -> dict:
-        total_distances = (
-            self._repository.meta.groupby("equipment")
-            .apply(
-                lambda group: pd.DataFrame(
-                    {
-                        "time": group["start"],
-                        "total_distance_km": group["distance_km"].cumsum(),
-                    }
-                ),
-                include_groups=False,
-            )
-            .reset_index()
-        )
-
-        plot = (
-            alt.Chart(
-                total_distances,
-                height=250,
-                width=250,
-                title="Equipment Usage over Time",
-            )
-            .mark_line(interpolate="step-after")
-            .encode(
-                alt.X("time", title="Date"),
-                alt.Y("total_distance_km", title="Cumulative distance / km"),
-            )
-            .facet("equipment", columns=4, title="Equipment")
-            .resolve_scale(y="independent")
-            .resolve_axis(x="independent")
-            .interactive()
-            .to_json(format="vega")
+        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,
         )
 
         equipment_summary = (
             self._repository.meta.groupby("equipment")
             .apply(
-                lambda group: pd.DataFrame(
+                lambda group: pd.Series(
                     {
                         "total_distance_km": group["distance_km"].sum(),
                         "first_use": group["start"].iloc[0],
                         "last_use": group["start"].iloc[-1],
                     },
-                    index=[0],
                 ),
                 include_groups=False,
             )
-            .reset_index()
             .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
+            ]
+            total_distances = pd.DataFrame(
+                {
+                    "time": selection["start"],
+                    "total_distance_km": selection["distance_km"].cumsum(),
+                }
+            )
+
+            total_distances_plot = (
+                alt.Chart(
+                    total_distances,
+                    height=300,
+                    width=300,
+                    title="Usage over Time",
+                )
+                .mark_line(interpolate="step-after")
+                .encode(
+                    alt.X("time", title="Date"),
+                    alt.Y("total_distance_km", title="Cumulative distance / km"),
+                )
+                .interactive()
+                .to_json(format="vega")
+            )
+
+            yearly_distance_plot = (
+                alt.Chart(
+                    selection,
+                    height=300,
+                    title="Yearly distance",
+                )
+                .mark_bar()
+                .encode(
+                    alt.X("year(start):O", title="Year"),
+                    alt.Y("sum(distance_km)", title="Distance / km"),
+                )
+                .to_json(format="vega")
+            )
+
+            usages_plot = (
+                alt.Chart(
+                    selection,
+                    height=300,
+                    title="Kinds",
+                )
+                .mark_bar()
+                .encode(
+                    alt.X("kind", title="Year"),
+                    alt.Y("sum(distance_km)", title="Distance / km"),
+                )
+                .to_json(format="vega")
+            )
+
+            equipment_variables[equipment] = {
+                "total_distances_plot": total_distances_plot,
+                "total_distances_plot_id": f"total_distances_plot_{hash(equipment)}",
+                "yearly_distance_plot": yearly_distance_plot,
+                "yearly_distance_plot_id": f"yearly_distance_plot_{hash(equipment)}",
+                "usages_plot": usages_plot,
+                "usages_plot_id": f"usages_plot_{hash(equipment)}",
+            }
+
         config = get_config()
         if "offsets" in config:
             for equipment, offset in config["offsets"].items():
-                equipment_summary.loc[
-                    equipment_summary["equipment"] == equipment, "total_distance_km"
-                ] += offset
+                equipment_summary.loc[equipment, "total_distance_km"] += offset
 
         return {
-            "total_distances_plot": plot,
-            "equipment_summary": equipment_summary.to_dict(orient="records"),
+            "equipment_variables": equipment_variables,
+            "equipment_summary": equipment_summary.reset_index().to_dict(
+                orient="records"
+            ),
         }

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

@@ -13,6 +13,7 @@
             <thead>
                 <tr>
                     <th>Equipment</th>
+                    <th>Primarily used for</th>
                     <th style="text-align: right;">Distance / km</th>
                     <th style="text-align: right;">First use</th>
                     <th style="text-align: right;">Last use</th>
@@ -22,6 +23,7 @@
                 {% for equipment in equipment_summary %}
                 <tr>
                     <td>{{ equipment.equipment }}</td>
+                    <td>{{ equipment.primarily_used_for }}</td>
                     <td style="text-align: right;">{{ equipment.total_distance_km|int }}</td>
                     <td style="text-align: right;">{{ equipment.first_use.date() }}</td>
                     <td style="text-align: right;">{{ equipment.last_use.date() }}</td>
@@ -34,13 +36,22 @@
 
 <div class="row mb-3">
     <div class="col">
-        <h2>Usage over time</h2>
+        <h2>Details for each equipment</h2>
     </div>
 </div>
 
+{% for equipment, data in equipment_variables.items() %}
+<h3>{{ equipment }}</h3>
 <div class="row mb-3">
-    <div class="col">
-        {{ vega_direct("total_distances_plot", total_distances_plot) }}
+    <div class="col-md-4">
+        {{ vega_direct(data.total_distances_plot_id, data.total_distances_plot) }}
+    </div>
+    <div class="col-md-4">
+        {{ vega_direct(data.yearly_distance_plot_id, data.yearly_distance_plot) }}
+    </div>
+    <div class="col-md-4">
+        {{ vega_direct(data.usages_plot_id, data.usages_plot) }}
     </div>
 </div>
+{% endfor %}
 {% endblock %}

geo_activity_playground/webui/heatmap/heatmap_controller.py

@@ -83,6 +83,12 @@ class HeatmapController:
             with work_tracker(
                 tile_count_cache_path.with_suffix(".json")
             ) as parsed_activities:
+                if parsed_activities - activity_ids:
+                    logger.warning(
+                        f"Resetting heatmap cache for {kind=}/{x=}/{y=}/{z=} because activities have been removed."
+                    )
+                    tile_counts = np.zeros(tile_pixels, dtype=np.int32)
+                    parsed_activities.clear()
                 for activity_id in activity_ids:
                     if activity_id in parsed_activities:
                         continue

geo_activity_playground/webui/strava/blueprint.py

@@ -0,0 +1,33 @@
+from flask import Blueprint
+from flask import redirect
+from flask import render_template
+from flask import request
+
+from .controller import StravaController
+
+
+def make_strava_blueprint(host: str, port: int) -> Blueprint:
+    strava_controller = StravaController(host, port)
+    blueprint = Blueprint("strava", __name__, template_folder="templates")
+
+    @blueprint.route("/setup")
+    def setup():
+        return render_template(
+            "strava/client-id.html.j2", **strava_controller.set_client_id()
+        )
+
+    @blueprint.route("/post-client-id", methods=["POST"])
+    def post_client_id():
+        client_id = request.form["client_id"]
+        client_secret = request.form["client_secret"]
+        url = strava_controller.save_client_id(client_id, client_secret)
+        return redirect(url)
+
+    @blueprint.route("/callback")
+    def strava_callback():
+        code = request.args.get("code", type=str)
+        return render_template(
+            "strava/connected.html.j2", **strava_controller.save_code(code)
+        )
+
+    return blueprint

geo_activity_playground/webui/strava/controller.py

@@ -0,0 +1,47 @@
+import json
+import urllib.parse
+from typing import Optional
+
+from geo_activity_playground.core.paths import strava_dynamic_config_path
+
+
+class StravaController:
+    def __init__(self, host: str, port: int) -> None:
+        self._host = host
+        self._port = port
+
+        self._client_secret: Optional[str] = None
+
+    def set_client_id(self) -> dict:
+        return {"host": self._host, "port": self._port}
+
+    def save_client_id(self, client_id: str, client_secret: str) -> str:
+        self._client_id = client_id
+        self._client_secret = client_secret
+
+        payload = {
+            "client_id": client_id,
+            "redirect_uri": f"http://{self._host}:{self._port}/strava/callback",
+            "response_type": "code",
+            "scope": "activity:read_all",
+        }
+
+        arg_string = "&".join(
+            f"{key}={urllib.parse.quote(value)}" for key, value in payload.items()
+        )
+        return f"https://www.strava.com/oauth/authorize?{arg_string}"
+
+    def save_code(self, code: str) -> dict:
+        self._code = code
+
+        with open(strava_dynamic_config_path(), "w") as f:
+            json.dump(
+                {
+                    "client_id": self._client_id,
+                    "client_secret": self._client_secret,
+                    "code": self._code,
+                },
+                f,
+            )
+
+        return {}

geo_activity_playground/webui/{templates/strava-connect.html.j2 → strava/templates/strava/client-id.html.j2}

@@ -6,21 +6,17 @@
 
 <div class="row mb-3">
     <div class="col-md-4">
-        <form action="/strava/authorize" method="POST">
+        <form action="/strava/post-client-id" method="POST">
             <div class="mb-3">
                 <label for="client_id" class="form-label">Client ID</label>
-                <input type="text" class="form-control" id="client_id" name="client_id" placeholder="814722" />
+                <input type="text" class="form-control" id="client_id" name="client_id" value="131693" />
             </div>
             <div class="mb-3">
                 <label for="client_secret" class="form-label">Client Secret</label>
                 <input type="text" class="form-control" id="client_secret" name="client_secret"
-                    placeholder="ed9d766e135d95c79dbfca4379d09661a72ebdfd" />
+                    value="0ccc0100a2c218512a7ef0cea3b0e322fb4b4365" />
             </div>
 
-
-            <input type="hidden" name="redirect_uri" value="http://{{ host }}:{{ port }}/strava/callback" />
-            <input type="hidden" name="response_type" value="code" />
-            <input type="hidden" name="scope" value="activity:read_all" />
             <input type="submit" value="Connect to Strava" />
         </form>
     </div>

geo_activity_playground/webui/strava/templates/strava/connected.html.j2

@@ -0,0 +1,14 @@
+{% extends "page.html.j2" %}
+
+{% block container %}
+
+<h1 class="mb-3">Strava Connect</h1>
+
+<div class="row mb-3">
+    <div class="col-md-4">
+        <p>You're now connected to Strava. Please restart the webserver to start loading actvities.</p>
+    </div>
+</div>
+
+
+{% endblock %}

geo_activity_playground/webui/summary/controller.py

@@ -61,11 +61,13 @@ def nominate_activities(meta: pd.DataFrame) -> dict[int, list[str]]:
     i = subset["elapsed_time"].idxmax()
     nominations[i].append(f"Longest elapsed time: {meta.loc[i].elapsed_time}")
 
-    i = subset["calories"].idxmax()
-    nominations[i].append(f"Most calories burnt: {meta.loc[i].calories:.0f} kcal")
+    if "calories" in subset.columns:
+        i = subset["calories"].idxmax()
+        nominations[i].append(f"Most calories burnt: {meta.loc[i].calories:.0f} kcal")
 
-    i = subset["steps"].idxmax()
-    nominations[i].append(f"Most steps: {meta.loc[i].steps:.0f}")
+    if "steps" in subset:
+        i = subset["steps"].idxmax()
+        nominations[i].append(f"Most steps: {meta.loc[i].steps:.0f}")
 
     for kind, group in meta.groupby("kind"):
         for key, text in [
@@ -83,10 +85,11 @@ def nominate_activities(meta: pd.DataFrame) -> dict[int, list[str]]:
             ),
             ("steps", lambda row: f"Most steps for {row.kind}: {row.steps:.0f}"),
         ]:
-            series = group[key]
-            i = series.idxmax()
-            if not pd.isna(i):
-                nominations[i].append(text(meta.loc[i]))
+            if key in group.columns:
+                series = group[key]
+                i = series.idxmax()
+                if not pd.isna(i):
+                    nominations[i].append(text(meta.loc[i]))
 
     return nominations
 

geo_activity_playground/webui/templates/home.html.j2

@@ -4,6 +4,7 @@
 <div class="row mb-3">
 </div>
 
+{% if latest_activities %}
 <div class="row mb-3">
     <div class="col-md-9">
         <h2>Last 30 days</h2>
@@ -63,5 +64,9 @@
     {% endfor %}
 </div>
 {% endfor %}
+{% else %}
+<p>You don't have activities yet. Either put some files into a directory <tt>Activities</tt> or <a
+        href="{{ url_for('strava.setup') }}">set up Strava API</a>.</p>
+{% endif %}
 
 {% endblock %}

geo_activity_playground/webui/templates/page.html.j2

@@ -90,6 +90,9 @@
                             <a class="nav-link active" aria-current="page"
                                 href="{{ url_for('upload.index') }}">Upload</a>
                         </li>
+                        <li class="nav-item">
+                            <a class="nav-link active" aria-current="page" href="{{ url_for('settings') }}">Settings</a>
+                        </li>
                     </ul>
                 </div>
             </div>

geo_activity_playground/webui/templates/settings.html.j2

@@ -0,0 +1,15 @@
+{% extends "page.html.j2" %}
+
+{% block container %}
+<div class="row mb-3">
+    <div class="col">
+        <h1>Settings</h1>
+    </div>
+</div>
+
+<div class="row mb-3">
+    <div class="col">
+        <p><a href="{{ url_for('strava.setup') }}">Set up Strava API</a>.</p>
+    </div>
+</div>
+{% endblock %}

geo_activity_playground/webui/upload/controller.py

@@ -10,7 +10,9 @@ from flask import Response
 from werkzeug.utils import secure_filename
 
 from geo_activity_playground.core.activities import ActivityRepository
-from geo_activity_playground.core.activities import embellish_time_series
+from geo_activity_playground.core.activities import build_activity_meta
+from geo_activity_playground.core.enrichment import enrich_activities
+from geo_activity_playground.core.paths import _strava_dynamic_config_path
 from geo_activity_playground.explorer.tile_visits import compute_tile_evolution
 from geo_activity_playground.explorer.tile_visits import compute_tile_visits
 from geo_activity_playground.explorer.tile_visits import TileVisitAccessor
@@ -94,22 +96,16 @@ def scan_for_activities(
     skip_strava: bool = False,
 ) -> None:
     if pathlib.Path("Activities").exists():
-        import_from_directory(
-            repository,
-            config.get("kind", {}),
-            config.get("metadata_extraction_regexes", []),
-        )
+        import_from_directory(config.get("metadata_extraction_regexes", []))
     if pathlib.Path("Strava Export").exists():
         import_from_strava_checkout(repository)
-    if "strava" in config and not skip_strava:
-        import_from_strava_api(repository)
+    if (_strava_dynamic_config_path.exists() or "strava" in config) and not skip_strava:
+        import_from_strava_api()
 
-    if len(repository) == 0:
-        logger.error(
-            f"No activities found. You need to either add activity files (GPX, FIT, …) to {pathlib.Path('Activities')} or set up the Strava API. Starting without any activities is unfortunately not supported."
-        )
-        sys.exit(1)
+    enrich_activities(config.get("kind", {}))
+    build_activity_meta()
+    repository.reload()
 
-    embellish_time_series(repository)
-    compute_tile_visits(repository, tile_visit_accessor)
-    compute_tile_evolution(tile_visit_accessor)
+    if len(repository) > 0:
+        compute_tile_visits(repository, tile_visit_accessor)
+        compute_tile_evolution(tile_visit_accessor)

{geo_activity_playground-0.24.1.dist-info → geo_activity_playground-0.25.0.dist-info}/METADATA

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