geo-activity-playground 0.40.0__py3-none-any.whl → 0.41.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

@@ -16,6 +16,7 @@ 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__)
 
@@ -79,22 +80,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 +101,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 +113,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 +124,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,6 +113,10 @@ class Activity(DB.Model):
     )
     kind: Mapped["Kind"] = relationship(back_populates="activities")
 
+    tags: Mapped[list["Tag"]] = relationship(
+        secondary=activity_tag_association_table, back_populates="activities"
+    )
+
     def __getitem__(self, item) -> Any:
         return self.to_dict()[item]
 
@@ -112,12 +125,12 @@ class Activity(DB.Model):
 
     @property
     def average_speed_moving_kmh(self) -> Optional[float]:
-        if self.moving_time is not None:
+        if self.moving_time:
             return self.distance_km / (self.moving_time.total_seconds() / 3_600)
 
     @property
     def average_speed_elapsed_kmh(self) -> Optional[float]:
-        if self.elapsed_time is not None:
+        if self.elapsed_time:
             return self.distance_km / (self.elapsed_time.total_seconds() / 3_600)
 
     @property
@@ -174,6 +187,74 @@ class Activity(DB.Model):
         )
 
 
+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 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"),
+        )
+        .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"
 

geo_activity_playground/core/test_datamodel.py

@@ -1,7 +1,20 @@
+import datetime
+
 from .datamodel import Activity
 
 
-def test_zero_duration() -> None:
+def test_no_duration() -> None:
     activity = Activity(name="Test", distance_km=10.0)
     assert activity.average_speed_elapsed_kmh is None
     assert activity.average_speed_moving_kmh is None
+
+
+def test_zero_duration() -> None:
+    activity = Activity(
+        name="Test",
+        distance_km=10.0,
+        elapsed_time=datetime.timedelta(seconds=0),
+        moving_time=datetime.timedelta(seconds=0),
+    )
+    assert activity.average_speed_elapsed_kmh is None
+    assert activity.average_speed_moving_kmh is None

geo_activity_playground/importers/strava_checkout.py

@@ -271,9 +271,8 @@ def convert_strava_checkout(
             continue
 
         activity_date = dateutil.parser.parse(row["Activity Date"])
-        activity_name = row["Activity Name"]
+        activity_name: str = row["Activity Name"]
         activity_kind = row["Activity Type"]
-        is_commute = row["Commute"] == "true" or row["Commute"] == True
         equipment = (
             nan_as_none(row["Activity Gear"])
             or nan_as_none(row["Bike"])
@@ -285,8 +284,6 @@ def convert_strava_checkout(
         activity_target = playground_path / "Activities" / str(activity_kind)
         if equipment:
             activity_target /= str(equipment)
-        if is_commute:
-            activity_target /= "Commute"
 
         activity_target /= "".join(
             [
@@ -294,7 +291,7 @@ def convert_strava_checkout(
                 "-",
                 f"{activity_date.hour:02d}-{activity_date.minute:02d}-{activity_date.second:02d}",
                 " ",
-                activity_name,
+                activity_name.replace("/", "_"),
             ]
             + activity_file.suffixes
         )

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

geo_activity_playground/webui/blueprints/activity_blueprint.py

@@ -21,9 +21,9 @@ from PIL import Image
 from PIL import ImageDraw
 
 from ...core.activities import ActivityRepository
+from ...core.activities import make_color_bar
 from ...core.activities import make_geojson_color_line
 from ...core.activities import make_geojson_from_time_series
-from ...core.activities import make_speed_color_bar
 from ...core.config import Config
 from ...core.datamodel import Activity
 from ...core.datamodel import DB
@@ -41,6 +41,8 @@ from ...explorer.grid_file import make_grid_points
 from ...explorer.tile_visits import TileVisitAccessor
 from ..authenticator import Authenticator
 from ..authenticator import needs_authentication
+from ..columns import column_elevation
+from ..columns import column_speed
 
 logger = logging.getLogger(__name__)
 
@@ -128,19 +130,34 @@ def make_activity_blueprint(
                 new_tiles_geojson[zoom] = make_grid_file_geojson(points)
             new_tiles_per_zoom[zoom] = len(new_tiles)
 
+        line_color_columns_avail = dict(
+            [(column.name, column) for column in [column_speed, column_elevation]]
+        )
+        line_color_column = (
+            request.args.get("line_color_column")
+            or next(iter(line_color_columns_avail.values())).name
+        )
+
         context = {
             "activity": activity,
             "line_json": line_json,
             "distance_time_plot": distance_time_plot(time_series),
-            "color_line_geojson": make_geojson_color_line(time_series),
+            "color_line_geojson": make_geojson_color_line(
+                time_series, line_color_column
+            ),
             "speed_time_plot": speed_time_plot(time_series),
             "speed_distribution_plot": speed_distribution_plot(time_series),
             "similar_activites": similar_activities,
-            "speed_color_bar": make_speed_color_bar(time_series),
+            "line_color_bar": make_color_bar(
+                time_series[line_color_column],
+                line_color_columns_avail[line_color_column].format,
+            ),
             "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,
+            "line_color_columns_avail": line_color_columns_avail,
         }
         if (
             heart_zones := _extract_heart_rate_zones(

geo_activity_playground/webui/blueprints/bubble_chart_blueprint.py

@@ -3,6 +3,10 @@ import pandas as pd
 from flask import Blueprint
 from flask import render_template
 
+from ..columns import column_distance
+from ..columns import column_elevation_gain
+from ..columns import ColumnDescription
+
 
 def make_bubble_chart_blueprint(repository) -> Blueprint:
     blueprint = Blueprint("bubble_chart", __name__, template_folder="templates")
@@ -19,11 +23,16 @@ def make_bubble_chart_blueprint(repository) -> Blueprint:
 
         # Prepare the bubble chart data
         bubble_data = activities[
-            ["start", "distance_km", "kind", "activity_id"]
+            [
+                "start",
+                "kind",
+                "activity_id",
+                column_distance.name,
+                column_elevation_gain.name,
+            ]
         ].rename(
             columns={
                 "start": "date",
-                "distance_km": "distance",
                 "kind": "activity",
                 "activity_id": "id",
             }
@@ -33,29 +42,45 @@ def make_bubble_chart_blueprint(repository) -> Blueprint:
             lambda x: f"/activity/{x}"
         )
 
-        # Create the bubble chart
-        bubble_chart = (
-            alt.Chart(bubble_data, title="Distance per Day (Bubble Chart)")
-            .mark_circle()
-            .encode(
-                x=alt.X("date:T", title="Date"),
-                y=alt.Y("distance:Q", title="Distance (km)"),
-                size=alt.Size(
-                    "distance:Q", scale=alt.Scale(range=[10, 300]), title="Distance"
-                ),
-                color=alt.Color("activity:N", title="Activity"),
-                tooltip=[
-                    alt.Tooltip("date:T", title="Date"),
-                    alt.Tooltip("distance:Q", title="Distance (km)", format=".1f"),
-                    alt.Tooltip("activity:N", title="Activity"),
-                    alt.Tooltip("activity_url:N", title="Activity Link"),
-                ],
-            )
-            .properties(height=800, width=1200)
-            .interactive()
-            .to_json(format="vega")
+        return render_template(
+            "bubble_chart/index.html.j2",
+            bubble_chart_distance=_make_bubble_chart(bubble_data, column_distance),
+            bubble_chart_elevation_gain=_make_bubble_chart(
+                bubble_data, column_elevation_gain
+            ),
         )
 
-        return render_template("bubble_chart/index.html.j2", bubble_chart=bubble_chart)
-
     return blueprint
+
+
+def _make_bubble_chart(bubble_data, column: ColumnDescription):
+    return (
+        alt.Chart(bubble_data, title=f"{column.display_name} per Day (Bubble Chart)")
+        .mark_circle()
+        .encode(
+            x=alt.X("date:T", title="Date"),
+            y=alt.Y(
+                f"{column.name}:Q",
+                title=f"{column.display_name} ({column.unit})",
+            ),
+            size=alt.Size(
+                f"{column.name}:Q",
+                scale=alt.Scale(range=[10, 300]),
+                title=f"{column.display_name}",
+            ),
+            color=alt.Color("activity:N", title="Activity"),
+            tooltip=[
+                alt.Tooltip("date:T", title="Date"),
+                alt.Tooltip(
+                    f"{column.name}:Q",
+                    title=f"{column.display_name} ({column.unit})",
+                    format=column.format,
+                ),
+                alt.Tooltip("activity:N", title="Activity"),
+                alt.Tooltip("activity_url:N", title="Activity Link"),
+            ],
+        )
+        .properties(height=800, width=1200)
+        .interactive()
+        .to_json(format="vega")
+    )

geo_activity_playground/webui/blueprints/calendar_blueprint.py

@@ -1,10 +1,14 @@
 import collections
 import datetime
 
+import pandas as pd
+import sqlalchemy
 from flask import Blueprint
 from flask import render_template
 
 from ...core.activities import ActivityRepository
+from ...core.datamodel import Activity
+from ...core.datamodel import DB
 
 
 def make_calendar_blueprint(repository: ActivityRepository) -> Blueprint:
@@ -12,9 +16,14 @@ def make_calendar_blueprint(repository: ActivityRepository) -> Blueprint:
 
     @blueprint.route("/")
     def index():
-        meta = repository.meta
+        data = DB.session.execute(
+            sqlalchemy.select(Activity.start, Activity.distance_km)
+        ).all()
+        df = pd.DataFrame(data)
+        df["year"] = df["start"].dt.year
+        df["month"] = df["start"].dt.month
 
-        monthly_distance = meta.groupby(
+        monthly_distance = df.groupby(
             ["year", "month"],
         ).apply(lambda group: sum(group["distance_km"]), include_groups=False)
         monthly_distance.name = "total_distance_km"
@@ -24,7 +33,7 @@ def make_calendar_blueprint(repository: ActivityRepository) -> Blueprint:
             .fillna(0.0)
         )
 
-        yearly_distance = meta.groupby(["year"]).apply(
+        yearly_distance = df.groupby(["year"]).apply(
             lambda group: sum(group["distance_km"]), include_groups=False
         )
         yearly_distance.name = "total_distance_km"
@@ -34,7 +43,6 @@ def make_calendar_blueprint(repository: ActivityRepository) -> Blueprint:
         }
 
         context = {
-            "num_activities": len(repository),
             "monthly_distances": monthly_pivot,
             "yearly_distances": yearly_distances,
         }