geo-activity-playground 0.24.0__tar.gz → 0.24.2__tar.gz

{geo_activity_playground-0.24.0 → geo_activity_playground-0.24.2}/PKG-INFO

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

{geo_activity_playground-0.24.0 → geo_activity_playground-0.24.2}/geo_activity_playground/core/activities.py

@@ -48,6 +48,10 @@ class ActivityRepository:
             self.meta = pd.read_parquet(activities_path())
             self.meta.index = self.meta["id"]
             self.meta.index.name = "index"
+            if not pd.api.types.is_dtype_equal(
+                self.meta["start"].dtype, "datetime64[ns]"
+            ):
+                self.meta["start"] = convert_to_datetime_ns(self.meta["start"])
         else:
             self.meta = pd.DataFrame()
 
@@ -88,6 +92,7 @@ class ActivityRepository:
                 old_df = self.meta.loc[is_kept]
             else:
                 old_df = self.meta
+
             self.meta = pd.concat([old_df, new_df])
             assert pd.api.types.is_dtype_equal(
                 self.meta["start"].dtype, "datetime64[ns]"

{geo_activity_playground-0.24.0 → geo_activity_playground-0.24.2}/geo_activity_playground/importers/strava_api.py

@@ -17,6 +17,7 @@ from tqdm import tqdm
 from geo_activity_playground.core.activities import ActivityRepository
 from geo_activity_playground.core.config import get_config
 from geo_activity_playground.core.paths import cache_dir
+from geo_activity_playground.core.time_conversion import convert_to_datetime_ns
 
 
 logger = logging.getLogger(__name__)
@@ -165,7 +166,7 @@ def try_import_strava(repository: ActivityRepository) -> bool:
                         "distance_km": activity.distance.magnitude / 1000,
                         "name": activity.name,
                         "kind": str(activity.type),
-                        "start": activity.start_date,
+                        "start": convert_to_datetime_ns(activity.start_date),
                         "elapsed_time": activity.elapsed_time,
                         "equipment": gear_names[activity.gear_id],
                         "calories": detailed_activity.calories,

{geo_activity_playground-0.24.0 → geo_activity_playground-0.24.2}/geo_activity_playground/webui/activity/blueprint.py

@@ -22,7 +22,7 @@ def make_activity_blueprint(
         repository, tile_visit_accessor, privacy_zones
     )
 
-    @blueprint.route("/activity/all")
+    @blueprint.route("/all")
     def all():
         return render_template(
             "activity/lines.html.j2", **activity_controller.render_all()

{geo_activity_playground-0.24.0 → geo_activity_playground-0.24.2}/geo_activity_playground/webui/activity/controller.py

@@ -452,7 +452,7 @@ def make_sharepic(activity: ActivityMeta, time_series: pd.DataFrame) -> bytes:
         f"\n{activity['distance_km']:.1f} km",
         re.sub(r"^0 days ", "", f"{activity['elapsed_time']}"),
     ]
-    if activity["calories"]:
+    if activity["calories"] and not pd.isna(activity["calories"]):
         facts.append(f"{activity['calories']:.0f} kcal")
     if activity["steps"] and not pd.isna(activity["steps"]):
         facts.append(f"{activity['steps']:.0f} steps")

geo_activity_playground-0.24.2/geo_activity_playground/webui/equipment/controller.py

@@ -0,0 +1,114 @@
+import altair as alt
+import pandas as pd
+
+from geo_activity_playground.core.activities import ActivityRepository
+from geo_activity_playground.core.config import get_config
+
+
+class EquipmentController:
+    def __init__(self, repository: ActivityRepository) -> None:
+        self._repository = repository
+
+    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,
+        )
+
+        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
+            ]
+            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, "total_distance_km"] += offset
+
+        return {
+            "equipment_variables": equipment_variables,
+            "equipment_summary": equipment_summary.reset_index().to_dict(
+                orient="records"
+            ),
+        }

{geo_activity_playground-0.24.0 → geo_activity_playground-0.24.2}/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-0.24.0 → geo_activity_playground-0.24.2}/geo_activity_playground/webui/heatmap/heatmap_controller.py

@@ -11,6 +11,7 @@ from geo_activity_playground.core.activities import ActivityRepository
 from geo_activity_playground.core.heatmap import convert_to_grayscale
 from geo_activity_playground.core.heatmap import GeoBounds
 from geo_activity_playground.core.heatmap import get_sensible_zoom_level
+from geo_activity_playground.core.heatmap import PixelBounds
 from geo_activity_playground.core.tasks import work_tracker
 from geo_activity_playground.core.tiles import get_tile
 from geo_activity_playground.core.tiles import get_tile_upper_left_lat_lon
@@ -140,8 +141,9 @@ class HeatmapController:
     ) -> bytes:
         geo_bounds = GeoBounds(south, west, north, east)
         tile_bounds = get_sensible_zoom_level(geo_bounds, (4000, 4000))
+        pixel_bounds = PixelBounds.from_tile_bounds(tile_bounds)
 
-        background = np.zeros((*tile_bounds.shape, 3))
+        background = np.zeros((*pixel_bounds.shape, 3))
         for x in range(tile_bounds.x_tile_min, tile_bounds.x_tile_max):
             for y in range(tile_bounds.y_tile_min, tile_bounds.y_tile_max):
                 tile = np.array(get_tile(tile_bounds.zoom, x, y)) / 255

{geo_activity_playground-0.24.0 → geo_activity_playground-0.24.2}/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-0.24.0 → geo_activity_playground-0.24.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "geo-activity-playground"
-version = "0.24.0"
+version = "0.24.2"
 description = "Analysis of geo data activities like rides, runs or hikes."
 authors = ["Martin Ueding <mu@martin-ueding.de>"]
 license = "MIT"

geo_activity_playground-0.24.0/geo_activity_playground/webui/equipment/controller.py

@@ -1,73 +0,0 @@
-import altair as alt
-import pandas as pd
-
-from geo_activity_playground.core.activities import ActivityRepository
-from geo_activity_playground.core.config import get_config
-
-
-class EquipmentController:
-    def __init__(self, repository: ActivityRepository) -> None:
-        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")
-        )
-
-        equipment_summary = (
-            self._repository.meta.groupby("equipment")
-            .apply(
-                lambda group: pd.DataFrame(
-                    {
-                        "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)
-        )
-
-        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
-
-        return {
-            "total_distances_plot": plot,
-            "equipment_summary": equipment_summary.to_dict(orient="records"),
-        }