geo-activity-playground 0.27.0__tar.gz → 0.28.0__tar.gz

{geo_activity_playground-0.27.0 → geo_activity_playground-0.28.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: geo-activity-playground
-Version: 0.27.0
+Version: 0.28.0
 Summary: Analysis of geo data activities like rides, runs or hikes.
 License: MIT
 Author: Martin Ueding

{geo_activity_playground-0.27.0 → geo_activity_playground-0.28.0}/geo_activity_playground/__main__.py

@@ -109,10 +109,9 @@ def make_activity_repository(
 
 
 def main_cache(basedir: pathlib.Path) -> None:
-    repository, tile_visit_accessor, config_accessor = make_activity_repository(
+    (repository, tile_visit_accessor, config_accessor) = make_activity_repository(
         basedir, False
     )
-    scan_for_activities(repository, tile_visit_accessor, config_accessor())
 
 
 if __name__ == "__main__":

{geo_activity_playground-0.27.0 → geo_activity_playground-0.28.0}/geo_activity_playground/core/activities.py

@@ -128,11 +128,11 @@ class ActivityRepository:
         else:
             return None
 
-    def get_activity_ids(self, only_achievements: bool = False) -> set[int]:
+    def get_activity_ids(self, only_achievements: bool = False) -> list[int]:
         if only_achievements:
-            return set(self.meta.loc[self.meta["consider_for_achievements"]].index)
+            return list(self.meta.loc[self.meta["consider_for_achievements"]].index)
         else:
-            return set(self.meta.index)
+            return list(self.meta.index)
 
     def iter_activities(self, new_to_old=True, dropna=False) -> Iterator[ActivityMeta]:
         direction = -1 if new_to_old else 1

{geo_activity_playground-0.27.0 → geo_activity_playground-0.28.0}/geo_activity_playground/core/config.py

@@ -29,10 +29,11 @@ class Config:
     heart_rate_maximum: Optional[int] = None
     kinds_without_achievements: list[str] = dataclasses.field(default_factory=list)
     metadata_extraction_regexes: list[str] = dataclasses.field(default_factory=list)
-    num_processes: Optional[int] = None
+    num_processes: Optional[int] = 1
     privacy_zones: dict[str, list[list[float]]] = dataclasses.field(
         default_factory=dict
     )
+    sharepic_suppressed_fields: list[str] = dataclasses.field(default_factory=list)
     strava_client_id: int = 131693
     strava_client_secret: str = "0ccc0100a2c218512a7ef0cea3b0e322fb4b4365"
     strava_client_code: Optional[str] = None

{geo_activity_playground-0.27.0 → geo_activity_playground-0.28.0}/geo_activity_playground/core/tasks.py

@@ -59,8 +59,8 @@ class WorkTracker:
         else:
             self._done = set()
 
-    def filter(self, ids: Iterable) -> set:
-        return set(ids) - self._done
+    def filter(self, ids: Iterable) -> list:
+        return [elem for elem in ids if elem not in self._done]
 
     def mark_done(self, id: int) -> None:
         self._done.add(id)

{geo_activity_playground-0.27.0 → geo_activity_playground-0.28.0}/geo_activity_playground/explorer/tile_visits.py

@@ -25,139 +25,159 @@ from geo_activity_playground.core.tiles import interpolate_missing_tile
 logger = logging.getLogger(__name__)
 
 
+class TileInfo(TypedDict):
+    activity_ids: set[int]
+    first_time: datetime.datetime
+    first_id: int
+    last_time: datetime.datetime
+    last_id: int
+
+
 class TileHistoryRow(TypedDict):
+    activity_id: int
     time: datetime.datetime
     tile_x: int
     tile_y: int
 
 
+class TileEvolutionState:
+    def __init__(self) -> None:
+        self.num_neighbors: dict[tuple[int, int], int] = {}
+        self.memberships: dict[tuple[int, int], tuple[int, int]] = {}
+        self.clusters: dict[tuple[int, int], list[tuple[int, int]]] = {}
+        self.cluster_evolution = pd.DataFrame()
+        self.square_start = 0
+        self.cluster_start = 0
+        self.max_square_size = 0
+        self.visited_tiles: set[tuple[int, int]] = set()
+        self.square_evolution = pd.DataFrame()
+        self.square_x: Optional[int] = None
+        self.square_y: Optional[int] = None
+
+
+class TileState(TypedDict):
+    tile_visits: dict[int, dict[tuple[int, int], TileInfo]]
+    tile_history: dict[int, pd.DataFrame]
+    activities_per_tile: dict[int, set[int]]
+    processed_activities: set[int]
+    evolution_state: dict[int, TileEvolutionState]
+    version: int
+
+
+TILE_STATE_VERSION = 2
+
+
 class TileVisitAccessor:
-    TILE_EVOLUTION_STATES_PATH = pathlib.Path("Cache/tile-evolution-state.pickle")
-    TILE_HISTORIES_PATH = pathlib.Path(f"Cache/tile-history.pickle")
-    TILE_VISITS_PATH = pathlib.Path(f"Cache/tile-visits.pickle")
-    ACTIVITIES_PER_TILE_PATH = pathlib.Path(f"Cache/activities-per-tile.pickle")
+    PATH = pathlib.Path("Cache/tile-state-2.pickle")
 
     def __init__(self) -> None:
-        self.visits: dict[int, dict[tuple[int, int], dict[str, Any]]] = try_load_pickle(
-            self.TILE_VISITS_PATH
-        ) or collections.defaultdict(dict)
-        "zoom → (tile_x, tile_y) → tile_info"
-
-        self.histories: dict[int, pd.DataFrame] = try_load_pickle(
-            self.TILE_HISTORIES_PATH
-        ) or collections.defaultdict(pd.DataFrame)
-
-        self.states = try_load_pickle(
-            self.TILE_EVOLUTION_STATES_PATH
-        ) or collections.defaultdict(TileEvolutionState)
-
-        self.activities_per_tile: dict[
-            int, dict[tuple[int, int], set[int]]
-        ] = try_load_pickle(self.ACTIVITIES_PER_TILE_PATH) or collections.defaultdict(
-            dict
-        )
+        self.tile_state: TileState = try_load_pickle(self.PATH)
+        if (
+            self.tile_state is None
+            or self.tile_state.get("version", None) != TILE_STATE_VERSION
+        ):
+            self.tile_state = make_tile_state()
+            # TODO: Reset work tracker
 
     def save(self) -> None:
-        with open(self.TILE_VISITS_PATH, "wb") as f:
-            pickle.dump(self.visits, f)
+        tmp_path = self.PATH.with_suffix(".tmp")
+        with open(tmp_path, "wb") as f:
+            pickle.dump(self.tile_state, f)
+        tmp_path.rename(self.PATH)
 
-        with open(self.TILE_HISTORIES_PATH, "wb") as f:
-            pickle.dump(self.histories, f)
 
-        with open(self.TILE_EVOLUTION_STATES_PATH, "wb") as f:
-            pickle.dump(self.states, f)
+def make_defaultdict_dict():
+    return collections.defaultdict(dict)
 
-        with open(self.ACTIVITIES_PER_TILE_PATH, "wb") as f:
-            pickle.dump(self.activities_per_tile, f)
 
+def make_defaultdict_set():
+    return collections.defaultdict(set)
+
+
+def make_tile_state() -> TileState:
+    tile_state: TileState = {
+        "tile_visits": collections.defaultdict(make_defaultdict_dict),
+        "tile_history": collections.defaultdict(pd.DataFrame),
+        "activities_per_tile": collections.defaultdict(make_defaultdict_set),
+        "processed_activities": set(),
+        "evolution_state": collections.defaultdict(TileEvolutionState),
+        "version": TILE_STATE_VERSION,
+    }
+    return tile_state
 
-def compute_tile_visits(
-    repository: ActivityRepository, tile_visits_accessor: TileVisitAccessor
-) -> None:
-    present_activity_ids = repository.get_activity_ids()
-    work_tracker = WorkTracker(work_tracker_path("tile-visits"))
-
-    changed_zoom_tile = collections.defaultdict(set)
-
-    # Delete visits from removed activities.
-    for zoom, activities_per_tile in tile_visits_accessor.activities_per_tile.items():
-        for tile, activity_ids in activities_per_tile.items():
-            deleted_ids = activity_ids - present_activity_ids
-            if deleted_ids:
-                logger.debug(
-                    f"Removing activities {deleted_ids} from tile {tile} at {zoom=}."
-                )
-                for activity_id in deleted_ids:
-                    activity_ids.remove(activity_id)
-                    work_tracker.discard(activity_id)
-                    changed_zoom_tile[zoom].add(tile)
 
-    # Add visits from new activities.
-    activity_ids_to_process = work_tracker.filter(repository.get_activity_ids())
+def compute_tile_visits_new(
+    repository: ActivityRepository, tile_visit_accessor: TileVisitAccessor
+) -> None:
+    work_tracker = WorkTracker(work_tracker_path("tile-state"))
     for activity_id in tqdm(
-        activity_ids_to_process, desc="Extract explorer tile visits"
+        work_tracker.filter(repository.get_activity_ids()), desc="Tile visits (new)"
     ):
-        for zoom in range(20):
-            for time, tile_x, tile_y in _tiles_from_points(
-                repository.get_time_series(activity_id), zoom
-            ):
-                tile = (tile_x, tile_y)
-                if tile not in tile_visits_accessor.activities_per_tile[zoom]:
-                    tile_visits_accessor.activities_per_tile[zoom][tile] = set()
-                tile_visits_accessor.activities_per_tile[zoom][tile].add(activity_id)
-                changed_zoom_tile[zoom].add(tile)
+        do_tile_stuff(repository, tile_visit_accessor.tile_state, activity_id)
         work_tracker.mark_done(activity_id)
-
-    # Update tile visits structure.
-    for zoom, changed_tiles in tqdm(
-        changed_zoom_tile.items(), desc="Incorporate changes in tiles"
-    ):
-        soa = {"activity_id": [], "time": [], "tile_x": [], "tile_y": []}
-
-        for tile in changed_tiles:
-            activity_ids = tile_visits_accessor.activities_per_tile[zoom][tile]
-            activities = [
-                repository.get_activity_by_id(activity_id)
-                for activity_id in activity_ids
-            ]
-            activities_to_consider = [
-                activity
-                for activity in activities
-                if activity["consider_for_achievements"]
-            ]
-            activities_to_consider.sort(key=lambda activity: activity["start"])
-
-            if activities_to_consider:
-                tile_visits_accessor.visits[zoom][tile] = {
-                    "first_time": activities_to_consider[0]["start"],
-                    "first_id": activities_to_consider[0]["id"],
-                    "last_time": activities_to_consider[-1]["start"],
-                    "last_id": activities_to_consider[-1]["id"],
-                    "activity_ids": {
-                        activity["id"] for activity in activities_to_consider
-                    },
-                }
-
-                soa["activity_id"].append(activities_to_consider[0]["id"])
-                soa["time"].append(activities_to_consider[0]["start"])
-                soa["tile_x"].append(tile[0])
-                soa["tile_y"].append(tile[1])
-            else:
-                if tile in tile_visits_accessor.visits[zoom]:
-                    del tile_visits_accessor.visits[zoom][tile]
-
-        df = pd.DataFrame(soa)
-        if len(df) > 0:
-            df = pd.concat([tile_visits_accessor.histories[zoom], df])
-            df.sort_values("time", inplace=True)
-            tile_visits_accessor.histories[zoom] = df.groupby(
-                ["tile_x", "tile_y"]
-            ).head(1)
-
-    tile_visits_accessor.save()
+    tile_visit_accessor.save()
     work_tracker.close()
 
 
+def do_tile_stuff(
+    repository: ActivityRepository, tile_state: TileState, activity_id: int
+) -> None:
+    activity = repository.get_activity_by_id(activity_id)
+    time_series = repository.get_time_series(activity_id)
+
+    activity_tiles = pd.DataFrame(
+        _tiles_from_points(time_series, 19), columns=["time", "tile_x", "tile_y"]
+    )
+    for zoom in reversed(range(20)):
+        activities_per_tile = tile_state["activities_per_tile"][zoom]
+
+        new_tile_history_soa = {
+            "activity_id": [],
+            "time": [],
+            "tile_x": [],
+            "tile_y": [],
+        }
+
+        activity_tiles = activity_tiles.groupby(["tile_x", "tile_y"]).head(1)
+
+        for time, tile in zip(
+            activity_tiles["time"],
+            zip(activity_tiles["tile_x"], activity_tiles["tile_y"]),
+        ):
+            if activity["consider_for_achievements"]:
+                if tile not in activities_per_tile:
+                    new_tile_history_soa["activity_id"].append(activity_id)
+                    new_tile_history_soa["time"].append(time)
+                    new_tile_history_soa["tile_x"].append(tile[0])
+                    new_tile_history_soa["tile_y"].append(tile[1])
+
+                tile_visit = tile_state["tile_visits"][zoom][tile]
+                if not tile_visit:
+                    tile_visit["activity_ids"] = {activity_id}
+                else:
+                    tile_visit["activity_ids"].add(activity_id)
+
+                first_time = tile_visit.get("first_time", None)
+                last_time = tile_visit.get("last_time", None)
+                if first_time is None or time < first_time:
+                    tile_visit["first_id"] = activity_id
+                    tile_visit["first_time"] = time
+                if last_time is None or time > last_time:
+                    tile_visit["last_id"] = activity_id
+                    tile_visit["last_time"] = time
+
+            activities_per_tile[tile].add(activity_id)
+
+        if new_tile_history_soa["activity_id"]:
+            tile_state["tile_history"][zoom] = pd.concat(
+                [tile_state["tile_history"][zoom], pd.DataFrame(new_tile_history_soa)]
+            )
+
+        # Move up one layer in the quad-tree.
+        activity_tiles["tile_x"] //= 2
+        activity_tiles["tile_y"] //= 2
+
+
 def _tiles_from_points(
     time_series: pd.DataFrame, zoom: int
 ) -> Iterator[tuple[datetime.datetime, int, int]]:
@@ -181,38 +201,19 @@ def _tiles_from_points(
                 yield (t1,) + interpolated
 
 
-class TileEvolutionState:
-    def __init__(self) -> None:
-        self.num_neighbors: dict[tuple[int, int], int] = {}
-        self.memberships: dict[tuple[int, int], tuple[int, int]] = {}
-        self.clusters: dict[tuple[int, int], list[tuple[int, int]]] = {}
-        self.cluster_evolution = pd.DataFrame()
-        self.square_start = 0
-        self.cluster_start = 0
-        self.max_square_size = 0
-        self.visited_tiles: set[tuple[int, int]] = set()
-        self.square_evolution = pd.DataFrame()
-        self.square_x: Optional[int] = None
-        self.square_y: Optional[int] = None
-
-
-def compute_tile_evolution(
-    tile_visits_accessor: TileVisitAccessor, config: Config
-) -> None:
+def compute_tile_evolution(tile_state: TileState, config: Config) -> None:
     for zoom in config.explorer_zoom_levels:
         _compute_cluster_evolution(
-            tile_visits_accessor.histories[zoom],
-            tile_visits_accessor.states[zoom],
+            tile_state["tile_history"][zoom],
+            tile_state["evolution_state"][zoom],
             zoom,
         )
         _compute_square_history(
-            tile_visits_accessor.histories[zoom],
-            tile_visits_accessor.states[zoom],
+            tile_state["tile_history"][zoom],
+            tile_state["evolution_state"][zoom],
             zoom,
         )
 
-    tile_visits_accessor.save()
-
 
 def _compute_cluster_evolution(
     tiles: pd.DataFrame, s: TileEvolutionState, zoom: int

{geo_activity_playground-0.27.0 → geo_activity_playground-0.28.0}/geo_activity_playground/importers/directory.py

@@ -61,7 +61,7 @@ def import_from_directory(
 
     if num_processes == 1:
         paths_with_errors = []
-        for path in tqdm(new_activity_paths, desc="Parse activity metadata"):
+        for path in tqdm(new_activity_paths, desc="Parse activity metadata (serially)"):
             errors = _cache_single_file(path)
             if errors:
                 paths_with_errors.append(errors)

{geo_activity_playground-0.27.0 → geo_activity_playground-0.28.0}/geo_activity_playground/webui/activity/controller.py

@@ -61,7 +61,9 @@ class ActivityController:
 
         new_tiles = {
             zoom: sum(
-                self._tile_visit_accessor.histories[zoom]["activity_id"]
+                self._tile_visit_accessor.tile_state["tile_history"][zoom][
+                    "activity_id"
+                ]
                 == activity["id"]
             )
             for zoom in [14, 17]
@@ -100,7 +102,9 @@ class ActivityController:
             time_series = privacy_zone.filter_time_series(time_series)
         if len(time_series) == 0:
             time_series = self._repository.get_time_series(id)
-        return make_sharepic(activity, time_series)
+        return make_sharepic(
+            activity, time_series, self._config.sharepic_suppressed_fields
+        )
 
     def render_day(self, year: int, month: int, day: int) -> dict:
         meta = self._repository.meta
@@ -411,7 +415,11 @@ def pixels_in_bounds(bounds: PixelBounds) -> int:
     return (bounds.x_max - bounds.x_min) * (bounds.y_max - bounds.y_min)
 
 
-def make_sharepic(activity: ActivityMeta, time_series: pd.DataFrame) -> bytes:
+def make_sharepic(
+    activity: ActivityMeta,
+    time_series: pd.DataFrame,
+    sharepic_suppressed_fields: list[str],
+) -> bytes:
     lat_lon_data = np.array([time_series["latitude"], time_series["longitude"]]).T
 
     geo_bounds = get_bounds(lat_lon_data)
@@ -448,19 +456,27 @@ def make_sharepic(activity: ActivityMeta, time_series: pd.DataFrame) -> bytes:
         draw.line(yx, fill="red", width=4)
 
     draw.rectangle([0, img.height - 70, img.width, img.height], fill=(0, 0, 0, 128))
-    facts = [
-        f"{activity['kind']}",
-        f"{activity['start'].date()}",
-        f"{activity['equipment']}",
-        f"\n{activity['distance_km']:.1f} km",
-        re.sub(r"^0 days ", "", f"{activity['elapsed_time']}"),
-    ]
+
+    facts = {
+        "kind": f"{activity['kind']}",
+        "start": f"{activity['start'].date()}",
+        "equipment": f"{activity['equipment']}",
+        "distance_km": f"\n{activity['distance_km']:.1f} km",
+        "elapsed_time": re.sub(r"^0 days ", "", f"{activity['elapsed_time']}"),
+    }
+
     if activity.get("calories", 0) and not pd.isna(activity["calories"]):
-        facts.append(f"{activity['calories']:.0f} kcal")
+        facts["calories"] = f"{activity['calories']:.0f} kcal"
     if activity.get("steps", 0) and not pd.isna(activity["steps"]):
-        facts.append(f"{activity['steps']:.0f} steps")
+        facts["steps"] = f"{activity['steps']:.0f} steps"
+
+    facts = {
+        key: value
+        for key, value in facts.items()
+        if not key in sharepic_suppressed_fields
+    }
 
-    draw.text((35, img.height - 70 + 10), "      ".join(facts), font_size=20)
+    draw.text((35, img.height - 70 + 10), "      ".join(facts.values()), font_size=20)
 
     # img_array = np.array(img) / 255
 

{geo_activity_playground-0.27.0 → geo_activity_playground-0.28.0}/geo_activity_playground/webui/activity/templates/activity/show.html.j2

@@ -111,11 +111,7 @@
 </div>
 
 {% if heartrate_time_plot is defined %}
-<div class="row mb-3">
-    <div class="col">
-        <h2>Heart rate</h2>
-    </div>
-</div>
+<h2>Heart rate</h2>
 
 <div class="row mb-3">
     <div class="col-md-4">
@@ -133,13 +129,12 @@
 </div>
 {% endif %}
 
-<div class="row mb-3">
-    <div class="col">
-        <h2>Share picture</h2>
+<h2>Share picture</h2>
 
-        <img src="{{ url_for('.sharepic', id=activity.id) }}" />
-    </div>
-</div>
+<p><img src="{{ url_for('.sharepic', id=activity.id) }}" /></p>
+
+<p>Not happy with the displayed data? <a href="{{ url_for('settings.sharepic') }}">Change share picture
+        settings</a>.</p>
 
 {% if similar_activites|length > 0 %}
 <div class="row mb-3">

{geo_activity_playground-0.27.0 → geo_activity_playground-0.28.0}/geo_activity_playground/webui/app.py

@@ -22,6 +22,8 @@ from .summary.blueprint import make_summary_blueprint
 from .tile.blueprint import make_tile_blueprint
 from .upload.blueprint import make_upload_blueprint
 from geo_activity_playground.core.config import ConfigAccessor
+from geo_activity_playground.webui.auth.blueprint import make_auth_blueprint
+from geo_activity_playground.webui.authenticator import Authenticator
 from geo_activity_playground.webui.settings.blueprint import make_settings_blueprint
 
 
@@ -71,9 +73,13 @@ def web_ui_main(
     app.config["UPLOAD_FOLDER"] = "Activities"
     app.secret_key = get_secret_key()
 
+    authenticator = Authenticator(config_accessor())
+
     route_search(app, repository)
     route_start(app, repository)
 
+    app.register_blueprint(make_auth_blueprint(authenticator), url_prefix="/auth")
+
     app.register_blueprint(
         make_activity_blueprint(
             repository,
@@ -97,7 +103,7 @@ def web_ui_main(
         make_heatmap_blueprint(repository, tile_visit_accessor), url_prefix="/heatmap"
     )
     app.register_blueprint(
-        make_settings_blueprint(config_accessor),
+        make_settings_blueprint(config_accessor, authenticator),
         url_prefix="/settings",
     )
     app.register_blueprint(
@@ -110,7 +116,9 @@ def web_ui_main(
     )
     app.register_blueprint(make_tile_blueprint(), url_prefix="/tile")
     app.register_blueprint(
-        make_upload_blueprint(repository, tile_visit_accessor, config_accessor()),
+        make_upload_blueprint(
+            repository, tile_visit_accessor, config_accessor(), authenticator
+        ),
         url_prefix="/upload",
     )
 

geo_activity_playground-0.28.0/geo_activity_playground/webui/auth/blueprint.py

@@ -0,0 +1,27 @@
+from flask import Blueprint
+from flask import redirect
+from flask import render_template
+from flask import request
+from flask import url_for
+
+from geo_activity_playground.webui.authenticator import Authenticator
+
+
+def make_auth_blueprint(authenticator: Authenticator) -> Blueprint:
+    blueprint = Blueprint("auth", __name__, template_folder="templates")
+
+    @blueprint.route("/", methods=["GET", "POST"])
+    def index():
+        if request.method == "POST":
+            authenticator.authenticate(request.form["password"])
+        return render_template(
+            "auth/index.html.j2",
+            is_authenticated=authenticator.is_authenticated(),
+        )
+
+    @blueprint.route("/logout")
+    def logout():
+        authenticator.logout()
+        return redirect(url_for(".index"))
+
+    return blueprint

geo_activity_playground-0.28.0/geo_activity_playground/webui/auth/templates/auth/index.html.j2

@@ -0,0 +1,21 @@
+{% extends "page.html.j2" %}
+
+{% block container %}
+<h1>Authentication</h1>
+
+{% if is_authenticated %}
+<p>You are either logged in or don't have a password set. You can do everything.</p>
+
+<a class="btn btn-primary" href="{{ url_for('.logout') }}">Log Out</a>
+{% else %}
+<form method="POST">
+    <div class="mb-3">
+        <label for="password" class="form-label">Password</label>
+        <input type="password" class="form-control" id="password" name="password" />
+    </div>
+
+    <button type="submit" class="btn btn-primary">Log In</button>
+</form>
+{% endif %}
+
+{% endblock %}

geo_activity_playground-0.28.0/geo_activity_playground/webui/authenticator.py

@@ -0,0 +1,49 @@
+import functools
+from typing import Callable
+
+from flask import flash
+from flask import redirect
+from flask import session
+from flask import url_for
+
+from geo_activity_playground.core.config import Config
+
+
+class Authenticator:
+    def __init__(self, config: Config) -> None:
+        self._config = config
+
+    def is_authenticated(self) -> bool:
+        print(
+            f"Password={self._config.upload_password}, Session={session.get('is_authenticated', False)}"
+        )
+        return not self._config.upload_password or session.get(
+            "is_authenticated", False
+        )
+
+    def authenticate(self, password: str) -> None:
+        if password == self._config.upload_password:
+            session["is_authenticated"] = True
+            session.permanent = True
+            flash("Login successful.", category="success")
+        else:
+            flash("Incorrect password.", category="warning")
+
+    def logout(self) -> None:
+        session["is_authenticated"] = False
+        flash("Logout successful.", category="success")
+
+
+def needs_authentication(authenticator: Authenticator) -> Callable:
+    def decorator(route: Callable) -> Callable:
+        @functools.wraps(route)
+        def wrapped_route(*args, **kwargs):
+            if authenticator.is_authenticated():
+                return route(*args, **kwargs)
+            else:
+                flash("You need to be logged in to view that site.", category="Warning")
+                return redirect(url_for("auth.index"))
+
+        return wrapped_route
+
+    return decorator

{geo_activity_playground-0.27.0 → geo_activity_playground-0.28.0}/geo_activity_playground/webui/equipment/controller.py

@@ -103,7 +103,8 @@ class EquipmentController:
             }
 
         for equipment, offset in self._config.equipment_offsets.items():
-            equipment_summary.loc[equipment, "total_distance_km"] += offset
+            if equipment in equipment_summary.index:
+                equipment_summary.loc[equipment, "total_distance_km"] += offset
 
         return {
             "equipment_variables": equipment_variables,

{geo_activity_playground-0.27.0 → geo_activity_playground-0.28.0}/geo_activity_playground/webui/explorer/controller.py

@@ -54,9 +54,9 @@ class ExplorerController:
         if zoom not in self._config_accessor().explorer_zoom_levels:
             return {"zoom_level_not_generated": zoom}
 
-        tile_evolution_states = self._tile_visit_accessor.states
-        tile_visits = self._tile_visit_accessor.visits
-        tile_histories = self._tile_visit_accessor.histories
+        tile_evolution_states = self._tile_visit_accessor.tile_state["evolution_state"]
+        tile_visits = self._tile_visit_accessor.tile_state["tile_visits"]
+        tile_histories = self._tile_visit_accessor.tile_state["tile_history"]
 
         medians = tile_histories[zoom].median()
         median_lat, median_lon = get_tile_upper_left_lat_lon(