geo-activity-playground 0.45.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

geo_activity_playground/core/datamodel.py

@@ -229,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/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/core/meta_search.py

@@ -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/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/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/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")