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

geo_activity_playground/webui/blueprints/eddington_blueprints.py

@@ -0,0 +1,253 @@
+import datetime
+from math import ceil
+
+import altair as alt
+import numpy as np
+import pandas as pd
+from flask import Blueprint
+from flask import render_template
+from flask import Request
+from flask import request
+
+from ...core.activities import ActivityRepository
+from ...core.meta_search import apply_search_query
+from ..columns import column_distance
+from ..columns import column_elevation_gain
+from ..columns import ColumnDescription
+from ..search_util import search_query_from_form
+from ..search_util import SearchQueryHistory
+
+
+def register_eddington_blueprint(
+    repository: ActivityRepository, search_query_history: SearchQueryHistory
+) -> Blueprint:
+    blueprint = Blueprint("eddington", __name__, template_folder="templates")
+
+    @blueprint.route("/")
+    def distance():
+        return _render_eddington_template(
+            repository, request, search_query_history, "distance", column_distance, [1]
+        )
+
+    @blueprint.route("/elevation_gain")
+    def elevation_gain():
+        return _render_eddington_template(
+            repository,
+            request,
+            search_query_history,
+            "elevation_gain",
+            column_elevation_gain,
+            [20, 10, 1],
+        )
+
+    return blueprint
+
+
+def _render_eddington_template(
+    repository: ActivityRepository,
+    request: Request,
+    search_query_history: SearchQueryHistory,
+    template_name,
+    column: ColumnDescription,
+    divisor_values_avail: list[int],
+) -> str:
+
+    column_name = column.name
+    display_name = column.display_name
+    divisor = int(request.args.get("eddington_divisor") or divisor_values_avail[0])
+
+    query = search_query_from_form(request.args)
+    search_query_history.register_query(query)
+    activities = (
+        apply_search_query(repository.meta, query)
+        .dropna(subset=["start", column_name])
+        .copy()
+    )
+
+    activities["year"] = [start.year for start in activities["start"]]
+    activities["date"] = [start.date() for start in activities["start"]]
+    activities["isoyear"] = [start.isocalendar().year for start in activities["start"]]
+    activities["isoweek"] = [start.isocalendar().week for start in activities["start"]]
+
+    en_per_day, eddington_df_per_day = _get_values_per_group(
+        activities.groupby("date"), column_name, divisor
+    )
+    en_per_week, eddington_df_per_week = _get_values_per_group(
+        activities.groupby(["isoyear", "isoweek"]), column_name, divisor
+    )
+
+    return render_template(
+        f"eddington/{template_name}.html.j2",
+        eddington_number=en_per_day,
+        logarithmic_plot=_make_eddington_plot(
+            eddington_df_per_day, en_per_day, "Days", column_name, display_name, divisor
+        ),
+        eddington_per_week=en_per_week,
+        eddington_per_week_plot=_make_eddington_plot(
+            eddington_df_per_week,
+            en_per_week,
+            "Weeks",
+            column_name,
+            display_name,
+            divisor,
+        ),
+        eddington_table=eddington_df_per_day.loc[
+            (eddington_df_per_day[column_name] > en_per_day)
+            & (eddington_df_per_day[column_name] <= en_per_day + 10 * divisor)
+            & (eddington_df_per_day[column_name] % divisor == 0)
+        ].to_dict(orient="records"),
+        eddington_table_weeks=eddington_df_per_week.loc[
+            (eddington_df_per_week[column_name] > en_per_week)
+            & (eddington_df_per_week[column_name] <= en_per_week + 10 * divisor)
+            & (eddington_df_per_week[column_name] % divisor == 0)
+        ].to_dict(orient="records"),
+        query=query.to_jinja(),
+        yearly_eddington=_get_yearly_eddington(activities, column_name, divisor),
+        eddington_number_history_plot=_get_eddington_number_history(
+            activities, column_name, divisor
+        ),
+        eddington_divisor=divisor,
+        divisor_values_avail=divisor_values_avail,
+    )
+
+
+def _get_values_per_group(grouped, columnName, divisor) -> tuple[int, pd.DataFrame]:
+    sum_per_group = grouped.apply(
+        lambda group: int(sum(group[columnName])), include_groups=False
+    )
+    counts = dict(zip(*np.unique(sorted(sum_per_group), return_counts=True)))
+    eddington = pd.DataFrame(
+        {columnName: d, "count": counts.get(d, 0)}
+        for d in range(max(counts.keys()) + 1)
+    )
+    eddington["total"] = eddington["count"][::-1].cumsum()[::-1]
+    eddington[f"{columnName}_div"] = eddington[columnName] // divisor
+    en = (
+        eddington.loc[eddington["total"] >= eddington[f"{columnName}_div"]][
+            "total"
+        ].iloc[-1]
+        * divisor
+    )
+    eddington["missing"] = eddington[f"{columnName}_div"] - eddington["total"]
+
+    return en, eddington
+
+
+def _make_eddington_plot(
+    eddington_df: pd.DataFrame,
+    en: int,
+    interval: str,
+    column_name: str,
+    display_name: str,
+    divisor: int,
+) -> dict:
+    x = list(range(1, max(eddington_df[column_name]) + 1))
+    y = [v / divisor for v in x]
+    return (
+        (
+            (
+                alt.Chart(
+                    eddington_df,
+                    height=500,
+                    width=800,
+                    title=f"{display_name} Eddington Number {en}",
+                )
+                .mark_area(interpolate="step")
+                .encode(
+                    alt.X(
+                        column_name,
+                        scale=alt.Scale(domainMin=0, domainMax=en * 3),
+                        title=display_name,
+                    ),
+                    alt.Y(
+                        "total",
+                        scale=alt.Scale(domainMax=en / divisor * 1.5),
+                        title=f"{interval} exceeding {display_name}",
+                    ),
+                    [
+                        alt.Tooltip(column_name, title=display_name),
+                        alt.Tooltip(
+                            "total", title=f"{interval} exceeding {display_name}"
+                        ),
+                        alt.Tooltip("missing", title=f"{interval} missing for next"),
+                    ],
+                )
+            )
+            + (
+                alt.Chart(pd.DataFrame({column_name: x, "total": y}))
+                .mark_line(color="red")
+                .encode(alt.X(column_name), alt.Y("total"))
+            )
+        )
+        .interactive(bind_x=True, bind_y=True)
+        .to_json(format="vega")
+    )
+
+
+def _get_eddington_number(elevation_gains: pd.Series, divisor: int) -> int:
+    if len(elevation_gains) == 1:
+        if elevation_gains.iloc[0] >= 1:
+            return 1
+        else:
+            0
+
+    sorted_elevation_gains = sorted(elevation_gains, reverse=True)
+
+    for number_of_days, elevation_gain in enumerate(sorted_elevation_gains, 1):
+        if elevation_gain / divisor < number_of_days:
+            return (number_of_days - 1) * divisor
+
+
+def _get_yearly_eddington(
+    meta: pd.DataFrame, columnName: str, divisor: int
+) -> dict[int, int]:
+    meta = meta.dropna(subset=["start", columnName]).copy()
+    meta["year"] = [start.year for start in meta["start"]]
+    meta["date"] = [start.date() for start in meta["start"]]
+
+    yearly_eddington = meta.groupby("year").apply(
+        lambda group: _get_eddington_number(
+            group.groupby("date").apply(
+                lambda group2: int(group2[columnName].sum()), include_groups=False
+            ),
+            divisor,
+        ),
+        include_groups=False,
+    )
+    return yearly_eddington.to_dict()
+
+
+def _get_eddington_number_history(
+    meta: pd.DataFrame, columnName: str, divisor: int
+) -> dict:
+
+    daily_elevation_gains = meta.groupby("date").apply(
+        lambda group2: int(group2[columnName].sum()), include_groups=False
+    )
+
+    eddington_number_history = {"date": [], "eddington_number": []}
+    top_days = []
+    for date, elevation_gain in daily_elevation_gains.items():
+        elevation_gain = elevation_gain / divisor
+        if len(top_days) == 0:
+            top_days.append(elevation_gain)
+        else:
+            if elevation_gain >= top_days[0]:
+                top_days.append(elevation_gain)
+                top_days.sort()
+        while top_days[0] < len(top_days):
+            top_days.pop(0)
+        eddington_number_history["date"].append(
+            datetime.datetime.combine(date, datetime.datetime.min.time())
+        )
+        eddington_number_history["eddington_number"].append(len(top_days) * divisor)
+    history = pd.DataFrame(eddington_number_history)
+
+    return (
+        alt.Chart(history)
+        .mark_line(interpolate="step-after")
+        .encode(
+            alt.X("date", title="Date"),
+            alt.Y("eddington_number", title="Eddington number"),
+        )
+    ).to_json(format="vega")

geo_activity_playground/webui/blueprints/entry_views.py

@@ -4,12 +4,18 @@ import datetime
 import altair as alt
 import flask
 import pandas as pd
+import sqlalchemy
 from flask import render_template
 from flask import Response
 
 from ...core.activities import ActivityRepository
 from ...core.activities import make_geojson_from_time_series
 from ...core.config import Config
+from ...core.datamodel import Activity
+from ...core.datamodel import DB
+from ..columns import column_distance
+from ..columns import column_elevation_gain
+from ..columns import ColumnDescription
 from ..plot_util import make_kind_scale
 
 
@@ -22,27 +28,32 @@ def register_entry_views(
 
         if len(repository):
             kind_scale = make_kind_scale(repository.meta, config)
-            context["distance_last_30_days_plot"] = _distance_last_30_days_meta_plot(
-                repository.meta, kind_scale
+            context["distance_last_30_days_plot"] = _last_30_days_meta_plot(
+                repository.meta, kind_scale, column_distance
+            )
+            context["elevation_gain_last_30_days_plot"] = _last_30_days_meta_plot(
+                repository.meta, kind_scale, column_elevation_gain
             )
 
-        meta = repository.meta.copy()
-        meta["date"] = meta["start"].dt.date
-
-        context["latest_activities"] = collections.defaultdict(list)
-        for date, activity_meta in list(meta.groupby("date"))[:-30:-1]:
-            for index, activity in activity_meta.iterrows():
-                time_series = repository.get_time_series(activity["id"])
-                context["latest_activities"][date].append(
+            context["latest_activities"] = collections.defaultdict(list)
+            for activity in DB.session.scalars(
+                sqlalchemy.select(Activity).order_by(Activity.start.desc()).limit(100)
+            ):
+                context["latest_activities"][activity.start.date()].append(
                     {
                         "activity": activity,
-                        "line_geojson": make_geojson_from_time_series(time_series),
+                        "line_geojson": make_geojson_from_time_series(
+                            activity.time_series
+                        ),
                     }
                 )
+
         return render_template("home.html.j2", **context)
 
 
-def _distance_last_30_days_meta_plot(meta: pd.DataFrame, kind_scale: alt.Scale) -> str:
+def _last_30_days_meta_plot(
+    meta: pd.DataFrame, kind_scale: alt.Scale, column: ColumnDescription
+) -> str:
     before_30_days = pd.to_datetime(
         datetime.datetime.now() - datetime.timedelta(days=31)
     )
@@ -51,17 +62,21 @@ def _distance_last_30_days_meta_plot(meta: pd.DataFrame, kind_scale: alt.Scale)
             meta.loc[meta["start"] > before_30_days],
             width=700,
             height=200,
-            title="Distance per day",
+            title=f"{column.display_name} per day",
         )
         .mark_bar()
         .encode(
             alt.X("yearmonthdate(start)", title="Date"),
-            alt.Y("sum(distance_km)", title="Distance / km"),
+            alt.Y(f"sum({column.name})", title=f"{column.name} / {column.unit}"),
             alt.Color("kind", scale=kind_scale, title="Kind"),
             [
                 alt.Tooltip("yearmonthdate(start)", title="Date"),
                 alt.Tooltip("kind", title="Kind"),
-                alt.Tooltip("sum(distance_km)", format=".1f", title="Distance / km"),
+                alt.Tooltip(
+                    f"sum({column.name})",
+                    format=column.format,
+                    title=f"{column.display_name} / {column.unit}",
+                ),
             ],
         )
         .to_json(format="vega")

geo_activity_playground/webui/blueprints/explorer_blueprint.py

@@ -1,12 +1,15 @@
 import datetime
+import io
 import itertools
 import logging
 
 import altair as alt
 import geojson
 import matplotlib
+import matplotlib.pyplot as pl
 import numpy as np
 import pandas as pd
+import sqlalchemy
 from flask import Blueprint
 from flask import flash
 from flask import redirect
@@ -17,6 +20,10 @@ from flask import url_for
 from ...core.activities import ActivityRepository
 from ...core.config import ConfigAccessor
 from ...core.coordinates import Bounds
+from ...core.datamodel import Activity
+from ...core.datamodel import DB
+from ...core.raster_map import ImageTransform
+from ...core.raster_map import TileGetter
 from ...core.tiles import compute_tile
 from ...core.tiles import get_tile_upper_left_lat_lon
 from ...explorer.grid_file import get_border_tiles
@@ -38,9 +45,10 @@ logger = logging.getLogger(__name__)
 
 def make_explorer_blueprint(
     authenticator: Authenticator,
-    repository: ActivityRepository,
     tile_visit_accessor: TileVisitAccessor,
     config_accessor: ConfigAccessor,
+    tile_getter: TileGetter,
+    image_transforms: dict[str, ImageTransform],
 ) -> Blueprint:
     blueprint = Blueprint("explorer", __name__, template_folder="templates")
 
@@ -59,7 +67,7 @@ def make_explorer_blueprint(
         )
 
         explored = get_three_color_tiles(
-            tile_visits[zoom], repository, tile_evolution_states[zoom], zoom
+            tile_visits[zoom], tile_evolution_states[zoom], zoom
         )
 
         context = {
@@ -151,12 +159,74 @@ def make_explorer_blueprint(
             headers={"Content-disposition": "attachment"},
         )
 
+    @blueprint.route("/<int:zoom>/server-side")
+    def server_side(zoom: int):
+        if zoom not in config_accessor().explorer_zoom_levels:
+            return {"zoom_level_not_generated": zoom}
+
+        tile_evolution_states = tile_visit_accessor.tile_state["evolution_state"]
+        tile_histories = tile_visit_accessor.tile_state["tile_history"]
+
+        medians = tile_histories[zoom].median()
+        median_lat, median_lon = get_tile_upper_left_lat_lon(
+            medians["tile_x"], medians["tile_y"], zoom
+        )
+
+        context = {
+            "center": {
+                "latitude": median_lat,
+                "longitude": median_lon,
+                "bbox": (
+                    bounding_box_for_biggest_cluster(
+                        tile_evolution_states[zoom].clusters.values(), zoom
+                    )
+                    if len(tile_evolution_states[zoom].memberships) > 0
+                    else {}
+                ),
+            },
+            "plot_tile_evolution": plot_tile_evolution(tile_histories[zoom]),
+            "plot_cluster_evolution": plot_cluster_evolution(
+                tile_evolution_states[zoom].cluster_evolution
+            ),
+            "plot_square_evolution": plot_square_evolution(
+                tile_evolution_states[zoom].square_evolution
+            ),
+            "zoom": zoom,
+        }
+        return render_template("explorer/server-side.html.j2", **context)
+
+    @blueprint.route("/<int:zoom>/tile/<int:z>/<int:x>/<int:y>.png")
+    def tile(zoom: int, z: int, x: int, y: int) -> Response:
+        tile_visits = tile_visit_accessor.tile_state["tile_visits"][zoom]
+
+        map_tile = np.array(tile_getter.get_tile(z, x, y)) / 255
+        if z >= zoom:
+            factor = 2 ** (z - zoom)
+            if (x // factor, y // factor) in tile_visits:
+                map_tile = image_transforms["color"].transform_image(map_tile)
+            else:
+                map_tile = image_transforms["color"].transform_image(map_tile) / 1.2
+        else:
+            grayscale = image_transforms["color"].transform_image(map_tile) / 1.2
+            factor = 2 ** (zoom - z)
+            width = 256 // factor
+            for xo in range(factor):
+                for yo in range(factor):
+                    if (x * factor + xo, y * factor + yo) not in tile_visits:
+                        map_tile[
+                            yo * width : (yo + 1) * width, xo * width : (xo + 1) * width
+                        ] = grayscale[
+                            yo * width : (yo + 1) * width, xo * width : (xo + 1) * width
+                        ]
+        f = io.BytesIO()
+        pl.imsave(f, map_tile, format="png")
+        return Response(bytes(f.getbuffer()), mimetype="image/png")
+
     return blueprint
 
 
 def get_three_color_tiles(
     tile_visits: dict,
-    repository: ActivityRepository,
     cluster_state: TileEvolutionState,
     zoom: int,
 ) -> str:
@@ -174,13 +244,17 @@ def get_three_color_tiles(
             last_age_days = 10000
         tile_dict[tile] = {
             "first_activity_id": str(tile_data["first_id"]),
-            "first_activity_name": repository.get_activity_by_id(tile_data["first_id"])[
-                "name"
-            ],
+            "first_activity_name": DB.session.scalar(
+                sqlalchemy.select(Activity.name).where(
+                    Activity.id == tile_data["first_id"]
+                )
+            ),
             "last_activity_id": str(tile_data["last_id"]),
-            "last_activity_name": repository.get_activity_by_id(tile_data["last_id"])[
-                "name"
-            ],
+            "last_activity_name": DB.session.scalar(
+                sqlalchemy.select(Activity.name).where(
+                    Activity.id == tile_data["last_id"]
+                )
+            ),
             "first_age_days": first_age_days,
             "first_age_color": matplotlib.colors.to_hex(
                 cmap_first(max(1 - first_age_days / (2 * 365), 0.0))