geo-activity-playground 0.44.0__tar.gz → 1.0.0__tar.gz

{geo_activity_playground-0.44.0 → geo_activity_playground-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: geo-activity-playground
-Version: 0.44.0
+Version: 1.0.0
 Summary: Analysis of geo data activities like rides, runs or hikes.
 License: MIT
 Author: Martin Ueding
@@ -28,6 +28,7 @@ Requires-Dist: gpxpy (>=1.5.0,<2.0.0)
 Requires-Dist: jinja2 (>=3.1.2,<4.0.0)
 Requires-Dist: matplotlib (>=3.10.1,<4.0.0)
 Requires-Dist: numpy (>=2.2.3,<3.0.0)
+Requires-Dist: openpyxl (>=3.1.5,<4.0.0)
 Requires-Dist: pandas (>=2.2.3,<3.0.0)
 Requires-Dist: pyarrow (>=19.0.1,<20.0.0)
 Requires-Dist: python-dateutil (>=2.8.2,<3.0.0)

{geo_activity_playground-0.44.0 → geo_activity_playground-1.0.0}/geo_activity_playground/core/config.py

@@ -38,6 +38,7 @@ class Config:
     privacy_zones: dict[str, list[list[float]]] = dataclasses.field(
         default_factory=dict
     )
+    reliable_elevation_measurements: bool = True
     sharepic_suppressed_fields: list[str] = dataclasses.field(default_factory=list)
     strava_client_id: int = 131693
     strava_client_secret: str = "0ccc0100a2c218512a7ef0cea3b0e322fb4b4365"

{geo_activity_playground-0.44.0 → geo_activity_playground-1.0.0}/geo_activity_playground/core/datamodel.py

@@ -29,6 +29,9 @@ from .paths import TIME_SERIES_DIR
 logger = logging.getLogger(__name__)
 
 
+DEFAULT_UNKNOWN_NAME = "Unknown"
+
+
 class ActivityMeta(TypedDict):
     average_speed_elapsed_kmh: float
     average_speed_moving_kmh: float
@@ -226,6 +229,9 @@ def query_activity_meta(clauses: list = []) -> pd.DataFrame:
         .order_by(Activity.start)
     ).all()
     df = pd.DataFrame(rows)
+    # If the search yields only activities without time information, the dtype isn't derived correctly.
+    df["start"] = pd.to_datetime(df["start"])
+    df["elapsed_time"] = pd.to_timedelta(df["elapsed_time"])
 
     if len(df):
         for old, new in [

geo_activity_playground-1.0.0/geo_activity_playground/core/export.py

@@ -0,0 +1,129 @@
+import io
+import zipfile
+from typing import IO
+
+import geojson
+import gpxpy.gpx
+import pandas as pd
+import sqlalchemy
+from tqdm import tqdm
+
+from .datamodel import Activity
+from .datamodel import DB
+from .datamodel import query_activity_meta
+
+
+def export_all(meta_format: str, activity_format: str) -> bytes:
+    meta = query_activity_meta()
+    buffer = io.BytesIO()
+    with zipfile.ZipFile(buffer, "x") as zf:
+        with zf.open(f"activities.{meta_format}", mode="w") as f:
+            match meta_format:
+                case "csv":
+                    export_meta_as_csv(meta, f)
+                case "json":
+                    export_meta_as_json(meta, f)
+                case "ods":
+                    export_meta_as_xlsx(meta, f)
+                case "parquet":
+                    export_meta_as_parquet(meta, f)
+                case "xlsx":
+                    export_meta_as_xlsx(meta, f)
+                case _:
+                    raise ValueError(
+                        f"Format {meta_format} is not supported for metadata."
+                    )
+        if activity_format:
+            zf.mkdir("activities")
+            for activity in tqdm(
+                DB.session.scalars(sqlalchemy.select(Activity)).all(),
+                desc="Export activity time series",
+            ):
+                with zf.open(
+                    f"activities/{activity.id}.{activity_format}", mode="w"
+                ) as f:
+                    match activity_format:
+                        case "csv":
+                            export_activity_as_csv(activity, f)
+                        case "geojson":
+                            export_activity_as_geojson(activity, f)
+                        case "gpx":
+                            export_activity_as_gpx(activity, f)
+                        case "ods":
+                            export_activity_as_xlsx(activity, f)
+                        case "parquet":
+                            export_activity_as_parquet(activity, f)
+                        case "xlsx":
+                            export_activity_as_xlsx(activity, f)
+                        case _:
+                            raise ValueError(
+                                f"Format {activity_format} is not supported for activity time series."
+                            )
+    return bytes(buffer.getbuffer())
+
+
+def export_meta_as_csv(meta: pd.DataFrame, target: IO[bytes]) -> None:
+    meta.to_csv(target, index=False)
+
+
+def export_meta_as_json(meta: pd.DataFrame, target: IO[bytes]) -> None:
+    buffer = io.StringIO()
+    meta.to_json(buffer, index=False)
+    target.write(buffer.getvalue().encode())
+
+
+def export_meta_as_parquet(meta: pd.DataFrame, target: IO[bytes]) -> None:
+    meta.to_parquet(target, index=False)
+
+
+def export_meta_as_xlsx(meta: pd.DataFrame, target: IO[bytes]) -> None:
+    meta.to_excel(target, index=False)
+
+
+def export_activity_as_csv(activity: Activity, target: IO[bytes]) -> None:
+    activity.time_series.to_csv(target, index=False)
+
+
+def export_activity_as_geojson(activity: Activity, target: IO[bytes]) -> None:
+    ts = activity.time_series
+    result = geojson.MultiLineString(
+        coordinates=[
+            [(lon, lat) for lat, lon in zip(group["latitude"], group["longitude"])]
+            for segment_id, group in ts.groupby("segment_id")
+        ]
+    )
+    buffer = io.StringIO()
+    geojson.dump(result, buffer)
+    target.write(buffer.getvalue().encode())
+
+
+def export_activity_as_gpx(activity: Activity, target: IO[bytes]) -> None:
+    g = gpxpy.gpx.GPX()
+
+    gpx_track = gpxpy.gpx.GPXTrack()
+    g.tracks.append(gpx_track)
+
+    ts = activity.time_series
+    for segment_id, group in ts.groupby("segment_id"):
+        gpx_segment = gpxpy.gpx.GPXTrackSegment()
+        gpx_track.segments.append(gpx_segment)
+
+        for index, row in group.iterrows():
+            gpx_segment.points.append(
+                gpxpy.gpx.GPXTrackPoint(
+                    row["latitude"],
+                    row["longitude"],
+                    elevation=row.get("elevation", None),
+                    time=row.get("time", None),
+                )
+            )
+
+    target.write(g.to_xml().encode())
+
+
+def export_activity_as_parquet(activity: Activity, target: IO[bytes]) -> None:
+    activity.time_series.to_parquet(target, index=False)
+
+
+def export_activity_as_xlsx(activity: Activity, target: IO[bytes]) -> None:
+    activity.time_series.to_excel(target, index=False)

{geo_activity_playground-0.44.0 → geo_activity_playground-1.0.0}/geo_activity_playground/core/meta_search.py

@@ -120,7 +120,7 @@ class SearchQuery:
             variables.append(("distance_km_max", self.distance_km_max))
 
         return "&".join(
-            f"{key}={urllib.parse.quote_plus(value)}" for key, value in variables
+            f"{key}={urllib.parse.quote_plus(str(value))}" for key, value in variables
         )
 
 
@@ -158,7 +158,7 @@ def apply_search_query(
         )
 
     if search_query.start_begin:
-        filter_clauses.append(Activity.start <= search_query.start_begin)
+        filter_clauses.append(Activity.start >= search_query.start_begin)
     if search_query.start_end:
         filter_clauses.append(Activity.start < search_query.start_end)
 

{geo_activity_playground-0.44.0 → geo_activity_playground-1.0.0}/geo_activity_playground/importers/directory.py

@@ -10,6 +10,7 @@ from tqdm import tqdm
 
 from ..core.config import Config
 from ..core.datamodel import ActivityMeta
+from ..core.datamodel import DEFAULT_UNKNOWN_NAME
 from ..core.paths import activity_extracted_dir
 from ..core.paths import activity_extracted_meta_dir
 from ..core.paths import activity_extracted_time_series_dir
@@ -84,8 +85,8 @@ def import_from_directory(
             # https://stackoverflow.com/a/74718395/653152
             name=path.name.removesuffix("".join(path.suffixes)),
             path=str(path),
-            kind="Unknown",
-            equipment="Unknown",
+            kind=DEFAULT_UNKNOWN_NAME,
+            equipment=DEFAULT_UNKNOWN_NAME,
             consider_for_achievements=True,
         )
         activity_meta.update(activity_meta_from_file)

{geo_activity_playground-0.44.0 → geo_activity_playground-1.0.0}/geo_activity_playground/importers/strava_checkout.py

@@ -13,6 +13,7 @@ import pandas as pd
 from tqdm import tqdm
 
 from ..core.datamodel import ActivityMeta
+from ..core.datamodel import DEFAULT_UNKNOWN_NAME
 from ..core.paths import activity_extracted_meta_dir
 from ..core.paths import activity_extracted_time_series_dir
 from ..core.paths import strava_last_activity_date_path
@@ -277,7 +278,7 @@ def convert_strava_checkout(
             nan_as_none(row["Activity Gear"])
             or nan_as_none(row["Bike"])
             or nan_as_none(row["Gear"])
-            or ""
+            or DEFAULT_UNKNOWN_NAME
         )
         activity_file = checkout_path / row["Filename"]
 

{geo_activity_playground-0.44.0 → geo_activity_playground-1.0.0}/geo_activity_playground/webui/app.py

@@ -38,6 +38,7 @@ from .blueprints.eddington_blueprints import register_eddington_blueprint
 from .blueprints.entry_views import register_entry_views
 from .blueprints.equipment_blueprint import make_equipment_blueprint
 from .blueprints.explorer_blueprint import make_explorer_blueprint
+from .blueprints.export_blueprint import make_export_blueprint
 from .blueprints.heatmap_blueprint import make_heatmap_blueprint
 from .blueprints.photo_blueprint import make_photo_blueprint
 from .blueprints.plot_builder_blueprint import make_plot_builder_blueprint
@@ -160,6 +161,7 @@ def web_ui_main(
             tile_getter,
             image_transforms,
         ),
+        "/export": make_export_blueprint(authenticator),
         "/heatmap": make_heatmap_blueprint(
             repository, tile_visit_accessor, config_accessor(), search_query_history
         ),
@@ -175,7 +177,7 @@ def web_ui_main(
         "/summary": make_summary_blueprint(repository, config, search_query_history),
         "/tile": make_tile_blueprint(image_transforms, tile_getter),
         "/upload": make_upload_blueprint(
-            repository, tile_visit_accessor, config_accessor(), authenticator
+            repository, tile_visit_accessor, config_accessor(), authenticator, flasher
         ),
     }
 

{geo_activity_playground-0.44.0 → geo_activity_playground-1.0.0}/geo_activity_playground/webui/authenticator.py

@@ -3,8 +3,10 @@ from typing import Callable
 
 from flask import flash
 from flask import redirect
+from flask import request
 from flask import session
 from flask import url_for
+from flask.typing import RouteCallable
 
 from ..core.config import Config
 
@@ -32,14 +34,14 @@ class Authenticator:
 
 
 def needs_authentication(authenticator: Authenticator) -> Callable:
-    def decorator(route: Callable) -> Callable:
+    def decorator(route: RouteCallable) -> RouteCallable:
         @functools.wraps(route)
         def wrapped_route(*args, **kwargs):
             if authenticator.is_authenticated():
                 return route(*args, **kwargs)
             else:
                 flash("You need to be logged in to view that site.", category="Warning")
-                return redirect(url_for("auth.index"))
+                return redirect(url_for("auth.index", redirect=request.url))
 
         return wrapped_route
 

{geo_activity_playground-0.44.0 → geo_activity_playground-1.0.0}/geo_activity_playground/webui/blueprints/auth_blueprint.py

@@ -14,9 +14,12 @@ def make_auth_blueprint(authenticator: Authenticator) -> Blueprint:
     def index():
         if request.method == "POST":
             authenticator.authenticate(request.form["password"])
+            if redirect_to := request.form["redirect"]:
+                return redirect(redirect_to)
         return render_template(
             "auth/index.html.j2",
             is_authenticated=authenticator.is_authenticated(),
+            redirect=request.args.get("redirect", ""),
         )
 
     @blueprint.route("/logout")

{geo_activity_playground-0.44.0 → geo_activity_playground-1.0.0}/geo_activity_playground/webui/blueprints/eddington_blueprints.py

@@ -26,7 +26,12 @@ def register_eddington_blueprint(
     @blueprint.route("/")
     def distance():
         return _render_eddington_template(
-            repository, request, search_query_history, "distance", column_distance, [1]
+            repository,
+            request,
+            search_query_history,
+            "distance",
+            column_distance,
+            [1],
         )
 
     @blueprint.route("/elevation_gain")
@@ -64,6 +69,10 @@ def _render_eddington_template(
         .copy()
     )
 
+    assert (
+        len(activities) > 0
+    ), "The filter has selected zero elements, that cannot work here."
+
     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"]]
@@ -111,24 +120,24 @@ def _render_eddington_template(
     )
 
 
-def _get_values_per_group(grouped, columnName, divisor) -> tuple[int, pd.DataFrame]:
+def _get_values_per_group(grouped, column_name, divisor) -> tuple[int, pd.DataFrame]:
     sum_per_group = grouped.apply(
-        lambda group: int(sum(group[columnName])), include_groups=False
+        lambda group: int(sum(group[column_name])), include_groups=False
     )
     counts = dict(zip(*np.unique(sorted(sum_per_group), return_counts=True)))
     eddington = pd.DataFrame(
-        {columnName: d, "count": counts.get(d, 0)}
+        {column_name: d, "count": counts.get(d, 0)}
         for d in range(max(counts.keys()) + 1)
     )
     eddington["total"] = eddington["count"][::-1].cumsum()[::-1]
-    eddington[f"{columnName}_div"] = eddington[columnName] // divisor
+    eddington[f"{column_name}_div"] = eddington[column_name] // divisor
     en = (
-        eddington.loc[eddington["total"] >= eddington[f"{columnName}_div"]][
-            "total"
+        eddington.loc[eddington["total"] >= eddington[f"{column_name}_div"]][
+            f"{column_name}_div"
         ].iloc[-1]
         * divisor
     )
-    eddington["missing"] = eddington[f"{columnName}_div"] - eddington["total"]
+    eddington["missing"] = eddington[f"{column_name}_div"] - eddington["total"]
 
     return en, eddington
 

{geo_activity_playground-0.44.0 → geo_activity_playground-1.0.0}/geo_activity_playground/webui/blueprints/entry_views.py

@@ -31,9 +31,11 @@ def register_entry_views(
             context["distance_last_30_days_plot"] = _last_30_days_meta_plot(
                 repository.meta, kind_scale, column_distance
             )
-            context["elevation_gain_last_30_days_plot"] = _last_30_days_meta_plot(
-                repository.meta, kind_scale, column_elevation_gain
-            )
+
+            if config.reliable_elevation_measurements:
+                context["elevation_gain_last_30_days_plot"] = _last_30_days_meta_plot(
+                    repository.meta, kind_scale, column_elevation_gain
+                )
 
             context["latest_activities"] = collections.defaultdict(list)
             for activity in DB.session.scalars(

{geo_activity_playground-0.44.0 → geo_activity_playground-1.0.0}/geo_activity_playground/webui/blueprints/equipment_blueprint.py

@@ -21,7 +21,7 @@ def make_equipment_blueprint(
         )
 
         # Prepare data for the stacked area chart
-        activities = repository.meta
+        activities = repository.meta.dropna(subset=["start"])
         activities["month"] = (
             activities["start"].dt.to_period("M").apply(lambda r: r.start_time)
         )