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

geo_activity_playground/alembic/versions/38882503dc7c_add_tags_to_activities.py

@@ -0,0 +1,70 @@
+from typing import Sequence
+from typing import Union
+
+import sqlalchemy as sa
+from alembic import op
+
+
+# revision identifiers, used by Alembic.
+revision: str = "38882503dc7c"
+down_revision: Union[str, None] = "93cc82ad1b60"
+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(
+        "tags",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("tag", sa.String(), nullable=False),
+        sa.PrimaryKeyConstraint("id"),
+        sa.UniqueConstraint("tag"),
+        sa.UniqueConstraint("tag", name="tags_tag"),
+    )
+    op.create_table(
+        "activity_tag_association_table",
+        sa.Column("left_id", sa.Integer(), nullable=False),
+        sa.Column("right_id", sa.Integer(), nullable=False),
+        sa.ForeignKeyConstraint(
+            ["left_id"],
+            ["activities.id"],
+        ),
+        sa.ForeignKeyConstraint(
+            ["right_id"],
+            ["tags.id"],
+        ),
+        sa.PrimaryKeyConstraint("left_id", "right_id"),
+    )
+    with op.batch_alter_table("plot_specs", schema=None) as batch_op:
+        batch_op.alter_column("mark", existing_type=sa.VARCHAR(), nullable=False)
+        batch_op.alter_column("x", existing_type=sa.VARCHAR(), nullable=False)
+        batch_op.alter_column("y", existing_type=sa.VARCHAR(), nullable=False)
+        batch_op.alter_column("color", existing_type=sa.VARCHAR(), nullable=False)
+        batch_op.alter_column("shape", existing_type=sa.VARCHAR(), nullable=False)
+        batch_op.alter_column("size", existing_type=sa.VARCHAR(), nullable=False)
+        batch_op.alter_column("row", existing_type=sa.VARCHAR(), nullable=False)
+        batch_op.alter_column("opacity", existing_type=sa.VARCHAR(), nullable=False)
+        batch_op.alter_column("column", existing_type=sa.VARCHAR(), nullable=False)
+        batch_op.alter_column("facet", existing_type=sa.VARCHAR(), nullable=False)
+
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("plot_specs", schema=None) as batch_op:
+        batch_op.alter_column("facet", existing_type=sa.VARCHAR(), nullable=True)
+        batch_op.alter_column("column", existing_type=sa.VARCHAR(), nullable=True)
+        batch_op.alter_column("opacity", existing_type=sa.VARCHAR(), nullable=True)
+        batch_op.alter_column("row", existing_type=sa.VARCHAR(), nullable=True)
+        batch_op.alter_column("size", existing_type=sa.VARCHAR(), nullable=True)
+        batch_op.alter_column("shape", existing_type=sa.VARCHAR(), nullable=True)
+        batch_op.alter_column("color", existing_type=sa.VARCHAR(), nullable=True)
+        batch_op.alter_column("y", existing_type=sa.VARCHAR(), nullable=True)
+        batch_op.alter_column("x", existing_type=sa.VARCHAR(), nullable=True)
+        batch_op.alter_column("mark", existing_type=sa.VARCHAR(), nullable=True)
+
+    op.drop_table("activity_tag_association_table")
+    op.drop_table("tags")
+    # ### end Alembic commands ###

geo_activity_playground/alembic/versions/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/core/activities.py

@@ -2,6 +2,7 @@ import datetime
 import functools
 import logging
 from collections.abc import Callable
+from collections.abc import Sequence
 from typing import Any
 from typing import Optional
 
@@ -16,21 +17,11 @@ from geo_activity_playground.core.datamodel import Activity
 from geo_activity_playground.core.datamodel import ActivityMeta
 from geo_activity_playground.core.datamodel import DB
 from geo_activity_playground.core.datamodel import Kind
+from geo_activity_playground.core.datamodel import query_activity_meta
 
 logger = logging.getLogger(__name__)
 
 
-def make_activity_meta() -> ActivityMeta:
-    return ActivityMeta(
-        calories=None,
-        commute=False,
-        consider_for_achievements=True,
-        equipment="Unknown",
-        kind="Unknown",
-        steps=None,
-    )
-
-
 class ActivityRepository:
     def __len__(self) -> int:
         return len(self.get_activity_ids())
@@ -51,14 +42,14 @@ class ActivityRepository:
         else:
             return None
 
-    def get_activity_ids(self, only_achievements: bool = False) -> list[int]:
+    def get_activity_ids(self, only_achievements: bool = False) -> Sequence[int]:
         query = sqlalchemy.select(Activity.id)
         if only_achievements:
             query = query.where(Kind.consider_for_achievements)
-        result = DB.session.scalars(query).all()
+        result = DB.session.scalars(query.order_by(Activity.start)).all()
         return result
 
-    def iter_activities(self, new_to_old=True, drop_na=False) -> list[Activity]:
+    def iter_activities(self, new_to_old=True, drop_na=False) -> Sequence[Activity]:
         query = sqlalchemy.select(Activity)
         if drop_na:
             query = query.where(Activity.start.is_not(None))
@@ -79,22 +70,8 @@ class ActivityRepository:
 
     @property
     def meta(self) -> pd.DataFrame:
-        activities = self.iter_activities(new_to_old=False, drop_na=True)
-        df = pd.DataFrame([activity.to_dict() for activity in activities])
-        df["date"] = df["start"].dt.date
-        df["year"] = [start.year for start in df["start"]]
-        df["month"] = [start.month for start in df["start"]]
-        df["day"] = [start.day for start in df["start"]]
-        df["week"] = [start.isocalendar().week for start in df["start"]]
-        df["day_of_week"] = df["start"].dt.day_of_week
-        df["iso_year"] = [start.isocalendar().year for start in df["start"]]
-        df["hours"] = [
-            elapsed_time.total_seconds() / 3600 for elapsed_time in df["elapsed_time"]
-        ]
-        df["hours_moving"] = [
-            moving_time.total_seconds() / 3600 for moving_time in df["moving_time"]
-        ]
-        df.index = df["id"]
+        df = query_activity_meta()
+
         return df
 
 
@@ -114,8 +91,8 @@ def inter_quartile_range(values):
     return np.quantile(values, 0.75) - np.quantile(values, 0.25)
 
 
-def make_geojson_color_line(time_series: pd.DataFrame) -> str:
-    low, high, clamp_speed = _make_speed_clamp(time_series["speed"])
+def make_geojson_color_line(time_series: pd.DataFrame, column: str) -> str:
+    low, high, clamp_value = _make_value_clamp(time_series[column])
     cmap = matplotlib.colormaps["viridis"]
     features = [
         geojson.Feature(
@@ -126,8 +103,8 @@ def make_geojson_color_line(time_series: pd.DataFrame) -> str:
                 ]
             ),
             properties={
-                "speed": next_row["speed"] if np.isfinite(next_row["speed"]) else 0.0,
-                "color": matplotlib.colors.to_hex(cmap(clamp_speed(next_row["speed"]))),
+                column: (next_row[column] if np.isfinite(next_row[column]) else 0.0),
+                "color": matplotlib.colors.to_hex(cmap(clamp_value(next_row[column]))),
             },
         )
         for _, group in time_series.groupby("segment_id")
@@ -137,21 +114,21 @@ def make_geojson_color_line(time_series: pd.DataFrame) -> str:
     return geojson.dumps(feature_collection)
 
 
-def make_speed_color_bar(time_series: pd.DataFrame) -> dict[str, Any]:
-    low, high, clamp_speed = _make_speed_clamp(time_series["speed"])
+def make_color_bar(time_series: pd.Series, format: str) -> dict[str, Any]:
+    low, high, clamp_value = _make_value_clamp(time_series)
     cmap = matplotlib.colormaps["viridis"]
     colors = [
-        (f"{speed:.1f}", matplotlib.colors.to_hex(cmap(clamp_speed(speed))))
-        for speed in np.linspace(low, high, 10)
+        (f"{value:{format}}", matplotlib.colors.to_hex(cmap(clamp_value(value))))
+        for value in np.linspace(low, high, 10)
     ]
     return {"low": low, "high": high, "colors": colors}
 
 
-def _make_speed_clamp(speeds: pd.Series) -> tuple[float, float, Callable]:
-    speed_without_na = speeds.dropna()
-    low = min(speed_without_na)
+def _make_value_clamp(values: pd.Series) -> tuple[float, float, Callable]:
+    values_without_na = values.dropna()
+    low = min(values_without_na)
     high = min(
-        max(speed_without_na),
-        np.median(speed_without_na) + 1.5 * inter_quartile_range(speed_without_na),
+        max(values_without_na),
+        np.median(values_without_na) + 1.5 * inter_quartile_range(values_without_na),
     )
-    return low, high, lambda speed: min(max((speed - low) / (high - low), 0.0), 1.0)
+    return low, high, lambda value: min(max((value - low) / (high - low), 0.0), 1.0)

geo_activity_playground/core/datamodel.py

@@ -10,8 +10,10 @@ import pandas as pd
 import sqlalchemy
 import sqlalchemy as sa
 from flask_sqlalchemy import SQLAlchemy
+from sqlalchemy import Column
 from sqlalchemy import ForeignKey
 from sqlalchemy import String
+from sqlalchemy import Table
 from sqlalchemy.orm import DeclarativeBase
 from sqlalchemy.orm import Mapped
 from sqlalchemy.orm import mapped_column
@@ -53,6 +55,13 @@ class Base(DeclarativeBase):
 
 DB = SQLAlchemy(model_class=Base)
 
+activity_tag_association_table = Table(
+    "activity_tag_association_table",
+    Base.metadata,
+    Column("left_id", ForeignKey("activities.id"), primary_key=True),
+    Column("right_id", ForeignKey("tags.id"), primary_key=True),
+)
+
 
 class Activity(DB.Model):
     __tablename__ = "activities"
@@ -104,8 +113,9 @@ class Activity(DB.Model):
     )
     kind: Mapped["Kind"] = relationship(back_populates="activities")
 
-    def __getitem__(self, item) -> Any:
-        return self.to_dict()[item]
+    tags: Mapped[list["Tag"]] = relationship(
+        secondary=activity_tag_association_table, back_populates="activities"
+    )
 
     def __str__(self) -> str:
         return f"{self.start} {self.name}"
@@ -114,11 +124,15 @@ class Activity(DB.Model):
     def average_speed_moving_kmh(self) -> Optional[float]:
         if self.moving_time:
             return self.distance_km / (self.moving_time.total_seconds() / 3_600)
+        else:
+            return None
 
     @property
     def average_speed_elapsed_kmh(self) -> Optional[float]:
         if self.elapsed_time:
             return self.distance_km / (self.elapsed_time.total_seconds() / 3_600)
+        else:
+            return None
 
     @property
     def raw_time_series(self) -> pd.DataFrame:
@@ -141,38 +155,85 @@ class Activity(DB.Model):
         else:
             return self.raw_time_series
 
-    def to_dict(self) -> ActivityMeta:
-        equipment = self.equipment.name if self.equipment is not None else "Unknown"
-        kind = self.kind.name if self.kind is not None else "Unknown"
-        consider_for_achievements = (
-            self.kind.consider_for_achievements if self.kind is not None else True
+
+class Tag(DB.Model):
+    __tablename__ = "tags"
+    __table_args__ = (sa.UniqueConstraint("tag", name="tags_tag"),)
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    tag: Mapped[str] = mapped_column(String, unique=True)
+
+    activities: Mapped[list[Activity]] = relationship(
+        secondary=activity_tag_association_table, back_populates="tags"
+    )
+
+
+def get_or_make_tag(tag: str) -> Tag:
+    tags = DB.session.scalars(sqlalchemy.select(Tag).where(Tag.tag == tag)).all()
+    if tags:
+        assert len(tags) == 1, f"There must be only one tag with name '{tag}'."
+        return tags[0]
+    else:
+        tag = Tag(tag=tag)
+        DB.session.add(tag)
+        return tag
+
+
+def query_activity_meta() -> pd.DataFrame:
+    rows = DB.session.execute(
+        sqlalchemy.select(
+            Activity.id,
+            Activity.name,
+            Activity.path,
+            Activity.distance_km,
+            Activity.start,
+            Activity.elapsed_time,
+            Activity.moving_time,
+            Activity.start_latitude,
+            Activity.start_longitude,
+            Activity.end_latitude,
+            Activity.end_longitude,
+            Activity.elevation_gain,
+            Activity.start_elevation,
+            Activity.end_elevation,
+            Activity.calories,
+            Activity.steps,
+            Activity.num_new_tiles_14,
+            Activity.num_new_tiles_17,
+            Kind.consider_for_achievements,
+            Equipment.name.label("equipment"),
+            Kind.name.label("kind"),
         )
-        return ActivityMeta(
-            id=self.id,
-            name=self.name,
-            path=self.path,
-            distance_km=self.distance_km,
-            start=self.start,
-            elapsed_time=self.elapsed_time,
-            moving_time=self.moving_time,
-            start_latitude=self.start_latitude,
-            start_longitude=self.start_longitude,
-            end_latitude=self.end_latitude,
-            end_longitude=self.end_longitude,
-            elevation_gain=self.elevation_gain,
-            start_elevation=self.start_elevation,
-            end_elevation=self.end_elevation,
-            calories=self.calories,
-            steps=self.steps,
-            num_new_tiles_14=self.num_new_tiles_14,
-            num_new_tiles_17=self.num_new_tiles_17,
-            equipment=equipment,
-            kind=kind,
-            average_speed_moving_kmh=self.average_speed_moving_kmh,
-            average_speed_elapsed_kmh=self.average_speed_elapsed_kmh,
-            consider_for_achievements=consider_for_achievements,
+        .join(Activity.equipment)
+        .join(Activity.kind)
+        .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"]
+
+    return df
+
 
 class Equipment(DB.Model):
     __tablename__ = "equipments"
@@ -195,6 +256,23 @@ class Equipment(DB.Model):
     __table_args__ = (sa.UniqueConstraint("name", name="equipments_name"),)
 
 
+def get_or_make_equipment(name: str, config: Config) -> Equipment:
+    equipments = DB.session.scalars(
+        sqlalchemy.select(Equipment).where(Equipment.name == name)
+    ).all()
+    if equipments:
+        assert (
+            len(equipments) == 1
+        ), f"There must be only one equipment with name '{name}'."
+        return equipments[0]
+    else:
+        equipment = Equipment(
+            name=name, offset_km=config.equipment_offsets.get(name, 0)
+        )
+        DB.session.add(equipment)
+        return equipment
+
+
 class Kind(DB.Model):
     __tablename__ = "kinds"
 
@@ -218,20 +296,6 @@ class Kind(DB.Model):
     __table_args__ = (sa.UniqueConstraint("name", name="kinds_name"),)
 
 
-class SquarePlannerBookmark(DB.Model):
-    __tablename__ = "square_planner_bookmarks"
-
-    id: Mapped[int] = mapped_column(primary_key=True)
-
-    zoom: Mapped[int] = mapped_column(sa.Integer, nullable=False)
-    x: Mapped[int] = mapped_column(sa.Integer, nullable=False)
-    y: Mapped[int] = mapped_column(sa.Integer, nullable=False)
-    size: Mapped[int] = mapped_column(sa.Integer, nullable=False)
-    name: Mapped[str] = mapped_column(sa.String, nullable=False)
-
-    __table_args__ = (sa.UniqueConstraint("zoom", "x", "y", "size", name="kinds_name"),)
-
-
 def get_or_make_kind(name: str, config: Config) -> Kind:
     kinds = DB.session.scalars(sqlalchemy.select(Kind).where(Kind.name == name)).all()
     if kinds:
@@ -246,21 +310,18 @@ def get_or_make_kind(name: str, config: Config) -> Kind:
         return kind
 
 
-def get_or_make_equipment(name: str, config: Config) -> Equipment:
-    equipments = DB.session.scalars(
-        sqlalchemy.select(Equipment).where(Equipment.name == name)
-    ).all()
-    if equipments:
-        assert (
-            len(equipments) == 1
-        ), f"There must be only one equipment with name '{name}'."
-        return equipments[0]
-    else:
-        equipment = Equipment(
-            name=name, offset_km=config.equipment_offsets.get(name, 0)
-        )
-        DB.session.add(equipment)
-        return equipment
+class SquarePlannerBookmark(DB.Model):
+    __tablename__ = "square_planner_bookmarks"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+
+    zoom: Mapped[int] = mapped_column(sa.Integer, nullable=False)
+    x: Mapped[int] = mapped_column(sa.Integer, nullable=False)
+    y: Mapped[int] = mapped_column(sa.Integer, nullable=False)
+    size: Mapped[int] = mapped_column(sa.Integer, nullable=False)
+    name: Mapped[str] = mapped_column(sa.String, nullable=False)
+
+    __table_args__ = (sa.UniqueConstraint("zoom", "x", "y", "size", name="kinds_name"),)
 
 
 class PlotSpec(DB.Model):

geo_activity_playground/core/enrichment.py

@@ -15,6 +15,7 @@ from .datamodel import ActivityMeta
 from .datamodel import DB
 from .datamodel import get_or_make_equipment
 from .datamodel import get_or_make_kind
+from .missing_values import some
 from .paths import activity_extracted_meta_dir
 from .paths import activity_extracted_time_series_dir
 from .paths import time_series_dir
@@ -82,9 +83,9 @@ def populate_database_from_extracted(config: Config) -> None:
             distance_km=0,
             equipment=equipment,
             kind=kind,
-            calories=extracted_metadata.get("calories", None),
-            elevation_gain=extracted_metadata.get("elevation_gain", None),
-            steps=extracted_metadata.get("steps", None),
+            calories=some(extracted_metadata.get("calories", None)),
+            elevation_gain=some(extracted_metadata.get("elevation_gain", None)),
+            steps=some(extracted_metadata.get("steps", None)),
             path=extracted_metadata.get("path", None),
             upstream_id=upstream_id,
         )
@@ -92,7 +93,13 @@ def populate_database_from_extracted(config: Config) -> None:
         update_via_time_series(activity, time_series)
 
         DB.session.add(activity)
-        DB.session.commit()
+        try:
+            DB.session.commit()
+        except sqlalchemy.exc.StatementError:
+            logger.error(
+                f"Could not insert the following activity into the database: {vars(activity)=}"
+            )
+            raise
 
         enriched_time_series_path = time_series_dir() / f"{activity.id}.parquet"
         time_series.to_parquet(enriched_time_series_path)

geo_activity_playground/core/missing_values.py

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

geo_activity_playground/core/test_missing_values.py

@@ -0,0 +1,19 @@
+import numpy as np
+
+from .missing_values import some
+
+
+def test_none() -> None:
+    assert some(None) == None
+
+
+def test_nan() -> None:
+    assert some(np.nan) == None
+
+
+def test_float() -> None:
+    assert some(1.0) == 1.0
+
+
+def test_integer() -> None:
+    assert some(1) == 1

geo_activity_playground/explorer/tile_visits.py

@@ -176,7 +176,7 @@ def _process_activity(
             activity_tiles["time"],
             zip(activity_tiles["tile_x"], activity_tiles["tile_y"]),
         ):
-            if activity["consider_for_achievements"]:
+            if activity.kind.consider_for_achievements:
                 if tile not in tile_state["tile_visits"][zoom]:
                     new_tile_history_soa["activity_id"].append(activity_id)
                     new_tile_history_soa["time"].append(time)

geo_activity_playground/webui/app.py

@@ -28,7 +28,7 @@ from .blueprints.activity_blueprint import make_activity_blueprint
 from .blueprints.auth_blueprint import make_auth_blueprint
 from .blueprints.bubble_chart_blueprint import make_bubble_chart_blueprint
 from .blueprints.calendar_blueprint import make_calendar_blueprint
-from .blueprints.eddington_blueprint import register_eddington_blueprint
+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
@@ -70,7 +70,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"}
@@ -137,7 +137,11 @@ def web_ui_main(
         "/eddington": register_eddington_blueprint(repository, search_query_history),
         "/equipment": make_equipment_blueprint(repository, config),
         "/explorer": make_explorer_blueprint(
-            authenticator, repository, tile_visit_accessor, config_accessor
+            authenticator,
+            tile_visit_accessor,
+            config_accessor,
+            tile_getter,
+            image_transforms,
         ),
         "/heatmap": make_heatmap_blueprint(
             repository, tile_visit_accessor, config_accessor(), search_query_history