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

geo_activity_playground/alembic/script.py.mako

@@ -1,10 +1,4 @@
-"""${message}
 
-Revision ID: ${up_revision}
-Revises: ${down_revision | comma,n}
-Create Date: ${create_date}
-
-"""
 from typing import Sequence, Union
 
 from alembic import op

geo_activity_playground/alembic/versions/da2cba03b71d_add_photos.py

@@ -0,0 +1,40 @@
+from typing import Sequence
+from typing import Union
+
+import sqlalchemy as sa
+from alembic import op
+
+
+# revision identifiers, used by Alembic.
+revision: str = "da2cba03b71d"
+down_revision: Union[str, None] = "38882503dc7c"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table(
+        "photos",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("filename", sa.String(), nullable=False),
+        sa.Column("time", sa.DateTime(), nullable=False),
+        sa.Column("latitude", sa.Float(), nullable=False),
+        sa.Column("longitude", sa.Float(), nullable=False),
+        sa.Column("activity_id", sa.Integer(), nullable=False),
+        sa.ForeignKeyConstraint(["activity_id"], ["activities.id"], name="activity_id"),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    with op.batch_alter_table("tags", schema=None) as batch_op:
+        batch_op.create_unique_constraint("tags_tag", ["tag"])
+
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("tags", schema=None) as batch_op:
+        batch_op.drop_constraint("tags_tag", type_="unique")
+
+    op.drop_table("photos")
+    # ### end Alembic commands ###

geo_activity_playground/alembic/versions/script.py.mako

@@ -1,4 +1,10 @@
+"""${message}
 
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
 from typing import Sequence, Union
 
 from alembic import op

geo_activity_playground/core/activities.py

@@ -24,7 +24,9 @@ logger = logging.getLogger(__name__)
 
 class ActivityRepository:
     def __len__(self) -> int:
-        return len(self.get_activity_ids())
+        return DB.session.scalars(
+            sqlalchemy.select(sqlalchemy.func.count()).select_from(Activity)
+        ).one()
 
     def has_activity(self, activity_id: int) -> bool:
         return bool(

geo_activity_playground/core/datamodel.py

@@ -1,6 +1,7 @@
 import datetime
 import json
 import logging
+import pathlib
 from typing import Any
 from typing import Optional
 from typing import TypedDict
@@ -117,6 +118,10 @@ class Activity(DB.Model):
         secondary=activity_tag_association_table, back_populates="activities"
     )
 
+    photos: Mapped[list["Photo"]] = relationship(
+        back_populates="activity", cascade="all, delete-orphan"
+    )
+
     def __str__(self) -> str:
         return f"{self.start} {self.name}"
 
@@ -179,7 +184,7 @@ def get_or_make_tag(tag: str) -> Tag:
         return tag
 
 
-def query_activity_meta() -> pd.DataFrame:
+def query_activity_meta(clauses: list = []) -> pd.DataFrame:
     rows = DB.session.execute(
         sqlalchemy.select(
             Activity.id,
@@ -206,31 +211,33 @@ def query_activity_meta() -> pd.DataFrame:
         )
         .join(Activity.equipment)
         .join(Activity.kind)
+        .where(*clauses)
         .order_by(Activity.start)
     ).all()
     df = pd.DataFrame(rows)
 
-    for old, new in [
-        ("elapsed_time", "average_speed_elapsed_kmh"),
-        ("moving_time", "average_speed_moving_kmh"),
-    ]:
-        df[new] = pd.NA
-        mask = df[old].dt.total_seconds() > 0
-        df.loc[mask, new] = df.loc[mask, "distance_km"] / (
-            df.loc[mask, old].dt.total_seconds() / 3_600
-        )
-
-    df["date"] = df["start"].dt.date
-    df["year"] = df["start"].dt.year
-    df["month"] = df["start"].dt.month
-    df["day"] = df["start"].dt.day
-    df["week"] = df["start"].dt.isocalendar().week
-    df["day_of_week"] = df["start"].dt.day_of_week
-    df["iso_year"] = df["start"].dt.isocalendar().year
-    df["hours"] = df["elapsed_time"].dt.total_seconds() / 3_600
-    df["hours_moving"] = df["moving_time"].dt.total_seconds() / 3_600
-
-    df.index = df["id"]
+    if len(df):
+        for old, new in [
+            ("elapsed_time", "average_speed_elapsed_kmh"),
+            ("moving_time", "average_speed_moving_kmh"),
+        ]:
+            df[new] = pd.NA
+            mask = df[old].dt.total_seconds() > 0
+            df.loc[mask, new] = df.loc[mask, "distance_km"] / (
+                df.loc[mask, old].dt.total_seconds() / 3_600
+            )
+
+        df["date"] = df["start"].dt.date
+        df["year"] = df["start"].dt.year
+        df["month"] = df["start"].dt.month
+        df["day"] = df["start"].dt.day
+        df["week"] = df["start"].dt.isocalendar().week
+        df["day_of_week"] = df["start"].dt.day_of_week
+        df["iso_year"] = df["start"].dt.isocalendar().year
+        df["hours"] = df["elapsed_time"].dt.total_seconds() / 3_600
+        df["hours_moving"] = df["moving_time"].dt.total_seconds() / 3_600
+
+        df.index = df["id"]
 
     return df
 
@@ -363,3 +370,22 @@ class PlotSpec(DB.Model):
         return json.dumps(
             {key: getattr(self, key) for key in self.FIELDS if getattr(self, key)}
         )
+
+
+class Photo(DB.Model):
+    __tablename__ = "photos"
+    id: Mapped[int] = mapped_column(primary_key=True)
+
+    filename: Mapped[str] = mapped_column(sa.String, nullable=False)
+    time: Mapped[datetime.datetime] = mapped_column(sa.DateTime, nullable=False)
+    latitude: Mapped[float] = mapped_column(sa.Float, nullable=False)
+    longitude: Mapped[float] = mapped_column(sa.Float, nullable=False)
+
+    activity_id: Mapped[int] = mapped_column(
+        ForeignKey("activities.id", name="activity_id"), nullable=False
+    )
+    activity: Mapped["Activity"] = relationship(back_populates="photos")
+
+    @property
+    def path(self) -> pathlib.Path:
+        return pathlib.Path(self.filename)

geo_activity_playground/core/enrichment.py

@@ -108,8 +108,10 @@ def populate_database_from_extracted(config: Config) -> None:
 def update_via_time_series(
     activity: Activity, time_series: pd.DataFrame
 ) -> ActivityMeta:
-    activity.start = time_series["time"].iloc[0]
-    activity.elapsed_time = time_series["time"].iloc[-1] - time_series["time"].iloc[0]
+    activity.start = some(time_series["time"].iloc[0])
+    activity.elapsed_time = some(
+        time_series["time"].iloc[-1] - time_series["time"].iloc[0]
+    )
     activity.distance_km = (
         time_series["distance_km"].iloc[-1] - time_series["distance_km"].iloc[0]
     )

geo_activity_playground/core/meta_search.py

@@ -2,21 +2,33 @@ import dataclasses
 import datetime
 import re
 import urllib.parse
+from collections.abc import Sequence
 from typing import Optional
 
 import dateutil.parser
 import numpy as np
 import pandas as pd
+import sqlalchemy
+
+from .datamodel import Activity
+from .datamodel import DB
+from .datamodel import Equipment
+from .datamodel import Kind
+from .datamodel import query_activity_meta
+from .datamodel import Tag
 
 
 @dataclasses.dataclass
 class SearchQuery:
-    equipment: list[str] = dataclasses.field(default_factory=list)
-    kind: list[str] = dataclasses.field(default_factory=list)
+    equipment: list[Equipment] = dataclasses.field(default_factory=list)
+    kind: list[Kind] = dataclasses.field(default_factory=list)
+    tag: list[Tag] = dataclasses.field(default_factory=list)
     name: Optional[str] = None
     name_case_sensitive: bool = False
     start_begin: Optional[datetime.date] = None
     start_end: Optional[datetime.date] = None
+    distance_km_min: Optional[float] = None
+    distance_km_max: Optional[float] = None
 
     def __str__(self) -> str:
         bits = []
@@ -25,10 +37,14 @@ class SearchQuery:
         if self.equipment:
             bits.append(
                 "equipment is "
-                + (" or ".join(f"“{equipment}”" for equipment in self.equipment))
+                + (" or ".join(f"“{equipment.name}”" for equipment in self.equipment))
             )
         if self.kind:
-            bits.append("kind is " + (" or ".join(f"“{kind}”" for kind in self.kind)))
+            bits.append(
+                "kind is " + (" or ".join(f"“{kind.name}”" for kind in self.kind))
+            )
+        if self.tag:
+            bits.append("tag is " + (" or ".join(f"“{tag.tag}”" for tag in self.tag)))
         if self.start_begin:
             bits.append(f"after “{self.start_begin.isoformat()}”")
         if self.start_end:
@@ -43,27 +59,38 @@ class SearchQuery:
             or self.name
             or self.start_begin
             or self.start_end
+            or self.tag
+            or self.distance_km_min
+            or self.distance_km_max
         )
 
     def to_primitives(self) -> dict:
         return {
-            "equipment": self.equipment,
-            "kind": self.kind,
+            "equipment": [equipment.id for equipment in self.equipment],
+            "kind": [kind.id for kind in self.kind],
+            "tag": [tag.id for tag in self.tag],
             "name": self.name or "",
             "name_case_sensitive": self.name_case_sensitive,
             "start_begin": _format_optional_date(self.start_begin),
             "start_end": _format_optional_date(self.start_end),
+            "distance_km_min": self.distance_km_min,
+            "distance_km_max": self.distance_km_max,
         }
 
     @classmethod
     def from_primitives(cls, d: dict) -> "SearchQuery":
         return cls(
-            equipment=d.get("equipment", []),
-            kind=d.get("kind", []),
+            equipment=[
+                DB.session.get_one(Equipment, id) for id in d.get("equipment", [])
+            ],
+            kind=[DB.session.get_one(Kind, id) for id in d.get("kind", [])],
+            tag=[DB.session.get_one(Tag, id) for id in d.get("tag", [])],
             name=d.get("name", None),
             name_case_sensitive=d.get("name_case_sensitive", False),
             start_begin=_parse_date_or_none(d.get("start_begin", None)),
             start_end=_parse_date_or_none(d.get("start_end", None)),
+            distance_km_min=d.get("distance_km_min", None),
+            distance_km_max=d.get("distance_km_max", None),
         )
 
     def to_jinja(self) -> dict:
@@ -74,9 +101,11 @@ class SearchQuery:
     def to_url_str(self) -> str:
         variables = []
         for equipment in self.equipment:
-            variables.append(("equipment", equipment))
+            variables.append(("equipment", equipment.id))
         for kind in self.kind:
-            variables.append(("kind", kind))
+            variables.append(("kind", kind.id))
+        for tag in self.tag:
+            variables.append(("tag", tag.id))
         if self.name:
             variables.append(("name", self.name))
         if self.name_case_sensitive:
@@ -85,6 +114,10 @@ class SearchQuery:
             variables.append(("start_begin", self.start_begin.isoformat()))
         if self.start_end:
             variables.append(("start_end", self.start_end.isoformat()))
+        if self.distance_km_min:
+            variables.append(("distance_km_min", self.distance_km_min))
+        if self.distance_km_max:
+            variables.append(("distance_km_max", self.distance_km_max))
 
         return "&".join(
             f"{key}={urllib.parse.quote_plus(value)}" for key, value in variables
@@ -94,36 +127,47 @@ class SearchQuery:
 def apply_search_query(
     activity_meta: pd.DataFrame, search_query: SearchQuery
 ) -> pd.DataFrame:
-    mask = _make_mask(activity_meta.index, True)
+
+    filter_clauses = []
 
     if search_query.equipment:
-        mask &= _filter_column(activity_meta["equipment"], search_query.equipment)
+        filter_clauses.append(
+            sqlalchemy.or_(
+                *[
+                    Activity.equipment == equipment
+                    for equipment in search_query.equipment
+                ]
+            )
+        )
+
     if search_query.kind:
-        mask &= _filter_column(activity_meta["kind"], search_query.kind)
-    if search_query.name:
-        mask &= pd.Series(
-            [
-                bool(
-                    re.search(
-                        search_query.name,
-                        activity_name,
-                        0 if search_query.name_case_sensitive else re.IGNORECASE,
-                    )
-                )
-                for activity_name in activity_meta["name"]
-            ],
-            index=activity_meta.index,
+        filter_clauses.append(
+            sqlalchemy.or_(*[Activity.kind == kind for kind in search_query.kind])
+        )
+
+    if search_query.tag:
+        filter_clauses.append(
+            sqlalchemy.or_(*[Activity.tags.contains(tag) for tag in search_query.tag])
         )
-    if search_query.start_begin is not None:
-        start_begin = datetime.datetime.combine(
-            search_query.start_begin, datetime.time.min
+
+    if search_query.name:
+        filter_clauses.append(
+            Activity.name.contains(search_query.name)
+            if search_query.name_case_sensitive
+            else Activity.name.icontains(search_query.name)
         )
-        mask &= start_begin <= activity_meta["start"]
-    if search_query.start_end is not None:
-        start_end = datetime.datetime.combine(search_query.start_end, datetime.time.max)
-        mask &= activity_meta["start"] <= start_end
 
-    return activity_meta.loc[mask]
+    if 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)
+
+    if search_query.distance_km_min:
+        filter_clauses.append(Activity.distance_km >= search_query.distance_km_min)
+    if search_query.distance_km_max:
+        filter_clauses.append(Activity.distance_km <= search_query.distance_km_max)
+
+    return query_activity_meta(filter_clauses)
 
 
 def _format_optional_date(date: Optional[datetime.date]) -> str:

geo_activity_playground/core/missing_values.py

@@ -1,13 +1,16 @@
+from typing import Any
 from typing import Optional
-from typing import Union
 
 import numpy as np
+import pandas as pd
 
 
-def some(value) -> Optional[Union[float, int]]:
+def some(value: Any) -> Optional[Any]:
     if value is None:
         return None
     elif np.isnan(value):
         return None
+    elif pd.isna(value):
+        return None
     else:
         return value

geo_activity_playground/core/paths.py

@@ -53,6 +53,7 @@ _strava_last_activity_date_path = _cache_dir / "strava-last-activity-date.json"
 _new_config_file = pathlib.Path("config.json")
 _activity_meta_override_dir = pathlib.Path("Metadata Override")
 _time_series_dir = pathlib.Path("Time Series")
+_photos_dir = pathlib.Path("Photos")
 
 
 cache_dir = dir_wrapper(_cache_dir)
@@ -65,6 +66,7 @@ tiles_per_time_series = dir_wrapper(_tiles_per_time_series)
 strava_api_dir = dir_wrapper(_strava_api_dir)
 activity_meta_override_dir = dir_wrapper(_activity_meta_override_dir)
 time_series_dir = dir_wrapper(_time_series_dir)
+PHOTOS_DIR = dir_wrapper(_photos_dir)
 
 activities_file = file_wrapper(_activities_file)
 strava_dynamic_config_path = file_wrapper(_strava_dynamic_config_path)

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