geo-activity-playground 0.41.0__py3-none-any.whl → 0.43.0__py3-none-any.whl

geo_activity_playground/webui/app.py

@@ -8,6 +8,7 @@ import secrets
 import shutil
 import urllib.parse
 
+import sqlalchemy
 from flask import Flask
 from flask import request
 from flask_alembic import Alembic
@@ -17,6 +18,10 @@ from ..core.config import ConfigAccessor
 from ..core.config import import_old_config
 from ..core.config import import_old_strava_config
 from ..core.datamodel import DB
+from ..core.datamodel import Equipment
+from ..core.datamodel import Kind
+from ..core.datamodel import Photo
+from ..core.datamodel import Tag
 from ..core.heart_rate import HeartRateZoneComputer
 from ..core.raster_map import GrayscaleImageTransform
 from ..core.raster_map import IdentityImageTransform
@@ -33,6 +38,7 @@ 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.heatmap_blueprint import make_heatmap_blueprint
+from .blueprints.photo_blueprint import make_photo_blueprint
 from .blueprints.plot_builder_blueprint import make_plot_builder_blueprint
 from .blueprints.search_blueprint import make_search_blueprint
 from .blueprints.settings_blueprint import make_settings_blueprint
@@ -70,7 +76,7 @@ def web_ui_main(
 
     app = Flask(__name__)
 
-    database_path = basedir / "database.sqlite"
+    database_path = pathlib.Path("database.sqlite")
     logger.info(f"Using database file at '{database_path.absolute()}'.")
     app.config["SQLALCHEMY_DATABASE_URI"] = f"sqlite:///{database_path.absolute()}"
     app.config["ALEMBIC"] = {"script_location": "../alembic/versions"}
@@ -146,6 +152,7 @@ def web_ui_main(
         "/heatmap": make_heatmap_blueprint(
             repository, tile_visit_accessor, config_accessor(), search_query_history
         ),
+        "/photo": make_photo_blueprint(config_accessor, authenticator, flasher),
         "/plot-builder": make_plot_builder_blueprint(
             repository, flasher, authenticator
         ),
@@ -178,15 +185,22 @@ def web_ui_main(
             "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(),
+            # "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())
+        variables["equipments_avail"] = DB.session.scalars(
+            sqlalchemy.select(Equipment).order_by(Equipment.name)
+        ).all()
+        variables["kinds_avail"] = DB.session.scalars(
+            sqlalchemy.select(Kind).order_by(Kind.name)
+        ).all()
+        variables["tags_avail"] = DB.session.scalars(
+            sqlalchemy.select(Tag).order_by(Tag.tag)
+        ).all()
+        variables["photo_count"] = DB.session.scalar(
+            sqlalchemy.select(sqlalchemy.func.count()).select_from(Photo)
+        )
         return variables
 
     app.run(host=host, port=port)

geo_activity_playground/webui/blueprints/activity_blueprint.py

@@ -29,6 +29,7 @@ from ...core.datamodel import Activity
 from ...core.datamodel import DB
 from ...core.datamodel import Equipment
 from ...core.datamodel import Kind
+from ...core.datamodel import Tag
 from ...core.enrichment import update_via_time_series
 from ...core.heart_rate import HeartRateZoneComputer
 from ...core.privacy_zones import PrivacyZone
@@ -71,14 +72,14 @@ def make_activity_blueprint(
                                 )
                             ]
                             for _, group in repository.get_time_series(
-                                activity["id"]
+                                activity.id
                             ).groupby("segment_id")
                         ]
                     ),
                     properties={
                         "color": matplotlib.colors.to_hex(cmap(i % 8)),
-                        "activity_name": activity["name"],
-                        "activity_id": str(activity["id"]),
+                        "activity_name": activity.name,
+                        "activity_id": str(activity.id),
                     },
                 )
                 for i, activity in enumerate(repository.iter_activities())
@@ -99,7 +100,7 @@ def make_activity_blueprint(
 
         meta = repository.meta
         similar_activities = meta.loc[
-            (meta.name == activity["name"]) & (meta.id != activity["id"])
+            (meta.name == activity.name) & (meta.id != activity.id)
         ]
         similar_activities = [row for _, row in similar_activities.iterrows()]
         similar_activities.reverse()
@@ -107,7 +108,7 @@ def make_activity_blueprint(
         new_tiles = {
             zoom: sum(
                 tile_visit_accessor.tile_state["tile_history"][zoom]["activity_id"]
-                == activity["id"]
+                == activity.id
             )
             for zoom in sorted(config.explorer_zoom_levels)
         }
@@ -117,7 +118,7 @@ def make_activity_blueprint(
         for zoom in sorted(config.explorer_zoom_levels):
             new_tiles = tile_visit_accessor.tile_state["tile_history"][zoom].loc[
                 tile_visit_accessor.tile_state["tile_history"][zoom]["activity_id"]
-                == activity["id"]
+                == activity.id
             ]
             if len(new_tiles):
                 points = make_grid_points(
@@ -152,8 +153,8 @@ def make_activity_blueprint(
                 time_series[line_color_column],
                 line_color_columns_avail[line_color_column].format,
             ),
-            "date": activity["start"].date(),
-            "time": activity["start"].time(),
+            "date": activity.start.date(),
+            "time": activity.start.time(),
             "new_tiles": new_tiles_per_zoom,
             "new_tiles_geojson": new_tiles_geojson,
             "line_color_column": line_color_column,
@@ -318,6 +319,7 @@ def make_activity_blueprint(
             abort(404)
         equipments = DB.session.scalars(sqlalchemy.select(Equipment)).all()
         kinds = DB.session.scalars(sqlalchemy.select(Kind)).all()
+        tags = DB.session.scalars(sqlalchemy.select(Tag)).all()
 
         if request.method == "POST":
             activity.name = request.form.get("name")
@@ -326,13 +328,18 @@ def make_activity_blueprint(
             if form_equipment == "null":
                 activity.equipment = None
             else:
-                activity.equipment = DB.session.get(Equipment, int(form_equipment))
+                activity.equipment = DB.session.get_one(Equipment, int(form_equipment))
 
             form_kind = request.form.get("kind")
             if form_kind == "null":
                 activity.kind = None
             else:
-                activity.kind = DB.session.get(Kind, int(form_kind))
+                activity.kind = DB.session.get_one(Kind, int(form_kind))
+
+            form_tags = request.form.getlist("tag")
+            activity.tags = [
+                DB.session.get_one(Tag, int(tag_id_str)) for tag_id_str in form_tags
+            ]
 
             DB.session.commit()
             return redirect(url_for(".show", id=activity.id))
@@ -342,6 +349,7 @@ def make_activity_blueprint(
             activity=activity,
             kinds=kinds,
             equipments=equipments,
+            tags=tags,
         )
 
     @blueprint.route("/trim/<id>", methods=["GET", "POST"])

geo_activity_playground/webui/blueprints/photo_blueprint.py

@@ -0,0 +1,198 @@
+import datetime
+import pathlib
+import uuid
+
+import dateutil.parser
+import exifread
+import geojson
+import sqlalchemy
+from flask import Blueprint
+from flask import redirect
+from flask import render_template
+from flask import request
+from flask import Response
+from flask import url_for
+from PIL import Image
+from PIL import ImageOps
+
+from ...core.config import ConfigAccessor
+from ...core.datamodel import Activity
+from ...core.datamodel import DB
+from ...core.datamodel import Photo
+from ...core.paths import PHOTOS_DIR
+from ..authenticator import Authenticator
+from ..authenticator import needs_authentication
+from ..flasher import Flasher
+from ..flasher import FlashTypes
+
+
+def ratio_to_decimal(numbers: list[exifread.utils.Ratio]) -> float:
+    deg, min, sec = numbers.values
+    return deg.decimal() + min.decimal() / 60 + sec.decimal() / 3600
+
+
+def get_metadata_from_image(path: pathlib.Path) -> dict:
+    with open(path, "rb") as f:
+        tags = exifread.process_file(f)
+    metadata = {}
+    try:
+        metadata["latitude"] = ratio_to_decimal(tags["GPS GPSLatitude"])
+        metadata["longitude"] = ratio_to_decimal(tags["GPS GPSLongitude"])
+    except KeyError:
+        pass
+    try:
+        metadata["time"] = datetime.datetime.strptime(
+            str(tags["EXIF DateTimeOriginal"]), "%Y:%m:%d %H:%M:%S"
+        )
+    except KeyError:
+        pass
+
+    return metadata
+
+
+def make_photo_blueprint(
+    config_accessor: ConfigAccessor, authenticator: Authenticator, flasher: Flasher
+) -> Blueprint:
+    blueprint = Blueprint("photo", __name__, template_folder="templates")
+
+    @blueprint.route("/get/<int:id>/<int:size>.webp")
+    def get(id: int, size: int) -> Response:
+        assert size < 5000
+        photo = DB.session.get_one(Photo, id)
+
+        original_path = PHOTOS_DIR() / "original" / photo.path
+        small_path = PHOTOS_DIR() / f"size-{size}" / photo.path.with_suffix(".webp")
+
+        if not small_path.exists():
+            with Image.open(original_path) as im:
+                target_size = (size, size)
+                im = ImageOps.contain(im, target_size)
+                small_path.parent.mkdir(exist_ok=True)
+                im.save(small_path)
+
+        with open(small_path, "rb") as f:
+            return Response(f.read(), mimetype="image/webp")
+
+    @blueprint.route("/map")
+    def map() -> str:
+        return render_template("photo/map.html.j2")
+
+    @blueprint.route("/map-for-all/photos.geojson")
+    def map_for_all() -> Response:
+        photos = DB.session.scalars(sqlalchemy.select(Photo)).all()
+        fc = geojson.FeatureCollection(
+            features=[
+                geojson.Feature(
+                    geometry=geojson.Point((photo.longitude, photo.latitude)),
+                    properties={
+                        "photo_id": photo.id,
+                        "url_marker": url_for(".get", id=photo.id, size=128),
+                        "url_popup": url_for(".get", id=photo.id, size=512),
+                        "url_full": url_for(".get", id=photo.id, size=4096),
+                    },
+                )
+                for photo in photos
+            ]
+        )
+        return Response(
+            geojson.dumps(fc, sort_keys=True, indent=2, ensure_ascii=False),
+            mimetype="application/json",
+        )
+
+    @blueprint.route("/map-for-activity/<int:activity_id>/photos.geojson")
+    def map_for_activity(activity_id: int) -> Response:
+        activity = DB.session.get_one(Activity, activity_id)
+        fc = geojson.FeatureCollection(
+            features=[
+                geojson.Feature(
+                    geometry=geojson.Point((photo.longitude, photo.latitude)),
+                    properties={
+                        "photo_id": photo.id,
+                        "url_marker": url_for(".get", id=photo.id, size=128),
+                        "url_popup": url_for(".get", id=photo.id, size=512),
+                        "url_full": url_for(".get", id=photo.id, size=4096),
+                    },
+                )
+                for photo in activity.photos
+            ]
+        )
+        return Response(
+            geojson.dumps(fc, sort_keys=True, indent=2, ensure_ascii=False),
+            mimetype="application/json",
+        )
+
+    @blueprint.route("/new", methods=["GET", "POST"])
+    @needs_authentication(authenticator)
+    def new() -> Response:
+        if request.method == "POST":
+            # check if the post request has the file part
+            if "file" not in request.files:
+                flasher.flash_message(
+                    "No file could be found. Did you select a file?", FlashTypes.WARNING
+                )
+                return redirect(url_for(".new"))
+
+            file = request.files["file"]
+            # If the user does not select a file, the browser submits an
+            # empty file without a filename.
+            if file.filename == "":
+                flasher.flash_message("No selected file.", FlashTypes.WARNING)
+                return redirect(url_for(".new"))
+            if not file:
+                flasher.flash_message("Empty file uploaded.", FlashTypes.WARNING)
+                return redirect(url_for(".new"))
+
+            filename = str(uuid.uuid4()) + pathlib.Path(file.filename).suffix
+            path = PHOTOS_DIR() / "original" / filename
+            path.parent.mkdir(exist_ok=True)
+            file.save(path)
+            metadata = get_metadata_from_image(path)
+
+            if "time" not in metadata:
+                flasher.flash_message(
+                    "Your image doesn't have the EXIF attribute 'EXIF DateTimeOriginal' and hence cannot be dated.",
+                    FlashTypes.DANGER,
+                )
+                return redirect(url_for(".new"))
+            time: datetime.datetime = metadata["time"]
+
+            activity = DB.session.scalar(
+                sqlalchemy.select(Activity)
+                .where(
+                    Activity.start.is_not(None),
+                    Activity.elapsed_time.is_not(None),
+                    Activity.start <= time,
+                )
+                .order_by(Activity.start.desc())
+                .limit(1)
+            )
+            if activity is None or activity.start + activity.elapsed_time < time:
+                flasher.flash_message(
+                    f"Your image is from {time} but no activity could be found. Please first upload an activity or fix the time in the photo",
+                    FlashTypes.DANGER,
+                )
+            print(activity)
+
+            if "latitude" not in metadata:
+                time_series = activity.time_series
+                print(time_series)
+                row = time_series.loc[time_series["time"] >= time].iloc[0]
+                metadata["latitude"] = row["latitude"]
+                metadata["longitude"] = row["longitude"]
+
+            photo = Photo(
+                filename=filename,
+                time=time,
+                latitude=metadata["latitude"],
+                longitude=metadata["longitude"],
+                activity=activity,
+            )
+
+            DB.session.add(photo)
+            DB.session.commit()
+
+            return redirect(f"/activity/{activity.id}")
+        else:
+            return render_template("photo/new.html.j2")
+
+    return blueprint

geo_activity_playground/webui/blueprints/settings_blueprint.py

@@ -18,6 +18,7 @@ from ...core.config import ConfigAccessor
 from ...core.datamodel import DB
 from ...core.datamodel import Equipment
 from ...core.datamodel import Kind
+from ...core.datamodel import Tag
 from ...core.heart_rate import HeartRateZoneComputer
 from ...core.paths import _activity_enriched_dir
 from ..authenticator import Authenticator
@@ -395,6 +396,37 @@ def make_settings_blueprint(
         strava_login_helper.save_strava_code(code)
         return redirect(url_for(".strava"))
 
+    @blueprint.route("/tags")
+    @needs_authentication(authenticator)
+    def tags_list():
+        return render_template(
+            "settings/tags-list.html.j2",
+            tags=DB.session.scalars(sqlalchemy.select(Tag)).all(),
+        )
+
+    @blueprint.route("/tags/new", methods=["GET", "POST"])
+    @needs_authentication(authenticator)
+    def tags_new():
+        if request.method == "POST":
+            tag_str = request.form["tag"]
+            tag = Tag(tag=tag_str)
+            DB.session.add(tag)
+            DB.session.commit()
+            return redirect(url_for(".tags_list"))
+        else:
+            return render_template("settings/tags-new.html.j2")
+
+    @blueprint.route("/tags/edit/<int:id>", methods=["GET", "POST"])
+    @needs_authentication(authenticator)
+    def tags_edit(id: int):
+        tag = DB.session.get_one(Tag, id)
+        if request.method == "POST":
+            tag.tag = request.form["tag"]
+            DB.session.commit()
+            return redirect(url_for(".tags_list"))
+        else:
+            return render_template("settings/tags-edit.html.j2", tag=tag)
+
     return blueprint
 
 

geo_activity_playground/webui/search_util.py

@@ -1,3 +1,5 @@
+from typing import Optional
+
 from werkzeug.datastructures import MultiDict
 
 from ..core.config import ConfigAccessor
@@ -7,13 +9,20 @@ from .authenticator import Authenticator
 
 
 def search_query_from_form(args: MultiDict) -> SearchQuery:
-    query = SearchQuery(
-        equipment=args.getlist("equipment"),
-        kind=args.getlist("kind"),
-        name=args.get("name", None),
-        name_case_sensitive=_parse_bool(args.get("name_case_sensitive", "false")),
-        start_begin=_parse_date_or_none(args.get("start_begin", None)),
-        start_end=_parse_date_or_none(args.get("start_end", None)),
+    query = SearchQuery.from_primitives(
+        {
+            "equipment": map(int, args.getlist("equipment")),
+            "kind": map(int, args.getlist("kind")),
+            "tag": map(int, args.getlist("tag")),
+            "name": args.get("name", None),
+            "name_case_sensitive": _parse_bool(
+                args.get("name_case_sensitive", "false")
+            ),
+            "start_begin": args.get("start_begin", None),
+            "start_end": args.get("start_end", None),
+            "distance_km_min": _optional_float(args.get("distance_km_min", None)),
+            "distance_km_max": _optional_float(args.get("distance_km_max", None)),
+        }
     )
 
     return query
@@ -23,6 +32,13 @@ def _parse_bool(s: str) -> bool:
     return s == "true"
 
 
+def _optional_float(s: str) -> Optional[float]:
+    if s:
+        return float(s)
+    else:
+        return None
+
+
 class SearchQueryHistory:
     def __init__(
         self, config_accessor: ConfigAccessor, authenticator: Authenticator

geo_activity_playground/webui/templates/activity/edit.html.j2

@@ -32,6 +32,21 @@
         </select>
     </div>
 
+    <div class="mb-3">
+        <label for="" class="form-label">Tags</label>
+        <div class="form-control">
+            {% for tag in tags %}
+            <div class="form-check form-check-inline">
+                <input class="form-check-input" type="checkbox" name="tag" value="{{ tag.id }}" id="tag_{{ tag.id }}" {%
+                    if tag in activity.tags %} checked {% endif %}>
+                <label class="form-check-label" for="tag_{{ tag.id }}">
+                    {{ tag.tag }}
+                </label>
+            </div>
+            {% endfor %}
+        </div>
+    </div>
+
     <button type="submit" class="btn btn-primary">Save</button>
 </form>
 

geo_activity_playground/webui/templates/activity/show.html.j2

@@ -10,14 +10,25 @@
 <div class="row mb-3">
     <div class="col-sm-12 col-md-4">
         <dl>
-            <dt>Name</dt>
-            <dd>{{ activity["name"] }}</dd>
-
             {% if activity.kind %}
             <dt>Kind</dt>
             <dd>{{ activity.kind.name }}</dd>
             {% endif %}
 
+            {% if activity.equipment %}
+            <dt>Equipment</dt>
+            <dd>{{ activity.equipment.name }}</dd>
+            {% endif %}
+
+            {% if activity.tags %}
+            <dt>Tags</dt>
+            <dd>
+                {% for tag in activity.tags %}
+                <span class="badge text-bg-primary">{{ tag.tag }}</span>
+                {% endfor %}
+            </dd>
+            {% endif %}
+
             <dt>Distance</dt>
             <dd>{{ activity.distance_km|round(1) }} km</dd>
 
@@ -52,11 +63,6 @@
             <dd>{{ activity.elevation_gain|round(0)|int }} m</dd>
             {% endif %}
 
-            {% if activity.equipment %}
-            <dt>Equipment</dt>
-            <dd>{{ activity.equipment.name }}</dd>
-            {% endif %}
-
             {% if new_tiles[14] %}
             <dt>New Explorer Tiles</dt>
             <dd>{{ new_tiles[14] }}</dd>
@@ -91,6 +97,30 @@
                 style: function (feature) { return { color: feature.properties.color } }
             }).addTo(map)
             map.fitBounds(geojson.getBounds());
+
+
+
+            fetch("{{ url_for('photo.map_for_activity', activity_id = activity.id) }}")
+                .then(function (response) {
+                    return response.json();
+                })
+                .then(function (data) {
+                    L.geoJSON(data, {
+                        pointToLayer: function (feature, latlng) {
+                            return L.marker(latlng, {
+                                icon: new L.Icon({
+                                    iconSize: [32, 32],
+                                    iconAnchor: [16, 16],
+                                    popupAnchor: [16, 0],
+                                    iconUrl: feature.properties.url_marker,
+                                })
+                            });
+                        },
+                        onEachFeature: function (feature, layer) {
+                            layer.bindPopup(`<a href="${feature.properties.url_full}" target="_blank"><img src="${feature.properties.url_popup}" /></a>`)
+                        }
+                    }).addTo(map);
+                });
         </script>
 
 
@@ -114,9 +144,11 @@
         <div class="mb-3" style="padding-top: 10px;">
             <form method="GET">
                 <label class="form-label">Line Color by</label>
-                <select class="form-select" aria-label="Line Color by" name="line_color_column" onchange="this.form.submit()">
+                <select class="form-select" aria-label="Line Color by" name="line_color_column"
+                    onchange="this.form.submit()">
                     {% for name, column in line_color_columns_avail.items() %}
-                    <option {% if name == line_color_column %} selected {% endif %} value="{{ name }}">{{ column.display_name }}</option>
+                    <option {% if name==line_color_column %} selected {% endif %} value="{{ name }}">{{
+                        column.display_name }}</option>
                     {% endfor %}
                 </select>
             </form>
@@ -124,8 +156,19 @@
     </div>
 </div>
 
-
+{% if activity.photos %}
+<h2 class="mb-3">Photos</h2>
 <div class="row mb-3">
+    {% for photo in activity.photos %}
+    <div class="col-md-3">
+        <img src="{{ url_for('photo.get', id=photo.id, size=512) }}" width="100%" />
+    </div>
+    {% endfor %}
+</div>
+{% endif %}
+
+
+<div class=" row mb-3">
     <div class="col">
         <h2>Distance & speed</h2>
     </div>
@@ -201,7 +244,8 @@
 
 {% if new_tiles_geojson %}
 <h2>New explorer tiles</h2>
-<p>With this activity you have explored new explorer tiles. The following maps show the new tiles on the respective zoom
+<p>With this activity you have explored new explorer tiles. The following maps show the new tiles on the respective
+    zoom
     levels.</p>
 <script>
     function add_map(id, geojson) {

geo_activity_playground/webui/templates/eddington/distance.html.j2

@@ -1,11 +1,10 @@
 {% extends "page.html.j2" %}
-{% from "search_form.html.j2" import search_form %}
 
 {% block container %}
 <h1 class="mb-3">Eddington Number</h1>
 
 <div class="mb-3">
-    {{ search_form(query, equipments_avail, kinds_avail, search_query_favorites, search_query_last, request_url) }}
+    {% include "search_form.html.j2" %}
 </div>
 
 <div class="row mb-3">

geo_activity_playground/webui/templates/eddington/elevation_gain.html.j2

@@ -1,11 +1,10 @@
 {% extends "page.html.j2" %}
-{% from "search_form.html.j2" import search_form %}
 
 {% block container %}
 <h1 class="mb-3">Eddington Number for Elevation Gain</h1>
 
 <div class="mb-3">
-    {{ search_form(query, equipments_avail, kinds_avail, search_query_favorites, search_query_last, request_url) }}
+    {% include "search_form.html.j2" %}
 </div>
 
 <div class="row mb-3">