geo-activity-playground 0.26.3__py3-none-any.whl → 0.27.1__py3-none-any.whl

geo_activity_playground/importers/strava_api.py

@@ -1,11 +1,8 @@
 import datetime
-import functools
-import json
 import logging
 import pathlib
 import pickle
 import time
-from typing import Any
 
 import pandas as pd
 from stravalib import Client
@@ -15,46 +12,28 @@ from stravalib.exc import RateLimitExceeded
 from tqdm import tqdm
 
 from geo_activity_playground.core.activities import ActivityMeta
-from geo_activity_playground.core.config import get_config
+from geo_activity_playground.core.config import Config
 from geo_activity_playground.core.paths import activity_extracted_meta_dir
 from geo_activity_playground.core.paths import activity_extracted_time_series_dir
-from geo_activity_playground.core.paths import cache_dir
 from geo_activity_playground.core.paths import strava_api_dir
-from geo_activity_playground.core.paths import strava_dynamic_config_path
+from geo_activity_playground.core.paths import strava_last_activity_date_path
+from geo_activity_playground.core.tasks import get_state
+from geo_activity_playground.core.tasks import set_state
 from geo_activity_playground.core.time_conversion import convert_to_datetime_ns
 
 
 logger = logging.getLogger(__name__)
 
 
-def get_state(path: pathlib.Path) -> Any:
-    if path.exists():
-        with open(path) as f:
-            return json.load(f)
-
-
-def set_state(path: pathlib.Path, state: Any) -> None:
-    path.parent.mkdir(exist_ok=True, parents=True)
-    with open(path, "w") as f:
-        json.dump(state, f, indent=2, sort_keys=True, ensure_ascii=False)
-
-
-def get_current_access_token() -> str:
-    if strava_dynamic_config_path().exists():
-        with open(strava_dynamic_config_path()) as f:
-            strava_config = json.load(f)
-    else:
-        config = get_config()
-        strava_config = config["strava"]
-
-    tokens = get_state(strava_api_dir() / "strava_tokens.json")
+def get_current_access_token(config: Config) -> str:
+    tokens = get_state(strava_api_dir() / "strava_tokens.json", None)
     if not tokens:
         logger.info("Create Strava access token …")
         client = Client()
         token_response = client.exchange_code_for_token(
-            client_id=strava_config["client_id"],
-            client_secret=strava_config["client_secret"],
-            code=strava_config["code"],
+            client_id=config.strava_client_id,
+            client_secret=config.strava_client_secret,
+            code=config.strava_client_code,
         )
         tokens = {
             "access": token_response["access_token"],
@@ -66,8 +45,8 @@ def get_current_access_token() -> str:
         logger.info("Renew Strava access token …")
         client = Client()
         token_response = client.refresh_access_token(
-            client_id=strava_config["client_id"],
-            client_secret=strava_config["client_secret"],
+            client_id=config.strava_client_id,
+            client_secret=config.strava_client_secret,
             refresh_token=tokens["refresh"],
         )
         tokens = {
@@ -89,8 +68,8 @@ def round_to_next_quarter_hour(date: datetime.datetime) -> datetime.datetime:
     return next_quarter
 
 
-def import_from_strava_api() -> None:
-    while try_import_strava():
+def import_from_strava_api(config: Config) -> None:
+    while try_import_strava(config):
         now = datetime.datetime.now()
         next_quarter = round_to_next_quarter_hour(now)
         seconds_to_wait = (next_quarter - now).total_seconds() + 10
@@ -100,17 +79,12 @@ def import_from_strava_api() -> None:
         time.sleep(seconds_to_wait)
 
 
-def try_import_strava() -> bool:
-    last_activity_date_path = cache_dir() / "strava-last-activity-date.json"
-    if last_activity_date_path.exists():
-        with open(last_activity_date_path) as f:
-            get_after = json.load(f)
-    else:
-        get_after = "2000-01-01T00:00:00Z"
+def try_import_strava(config: Config) -> bool:
+    get_after = get_state(strava_last_activity_date_path(), "2000-01-01T00:00:00Z")
 
     gear_names = {None: "None"}
 
-    client = Client(access_token=get_current_access_token())
+    client = Client(access_token=get_current_access_token(config))
 
     try:
         for activity in tqdm(
@@ -178,8 +152,10 @@ def try_import_strava() -> bool:
                 ) as f:
                     pickle.dump(activity_meta, f)
 
-            with open(last_activity_date_path, "w") as f:
-                json.dump(activity.start_date.isoformat().replace("+00:00", "Z"), f)
+            set_state(
+                strava_last_activity_date_path(),
+                activity.start_date.isoformat().replace("+00:00", "Z"),
+            )
 
         limit_exceeded = False
     except RateLimitExceeded:

geo_activity_playground/importers/strava_checkout.py

@@ -13,13 +13,18 @@ import numpy as np
 import pandas as pd
 from tqdm import tqdm
 
+from geo_activity_playground.core.activities import ActivityMeta
 from geo_activity_playground.core.paths import activity_extracted_meta_dir
 from geo_activity_playground.core.paths import activity_extracted_time_series_dir
+from geo_activity_playground.core.paths import strava_last_activity_date_path
+from geo_activity_playground.core.tasks import get_state
+from geo_activity_playground.core.tasks import set_state
 from geo_activity_playground.core.tasks import work_tracker_path
 from geo_activity_playground.core.tasks import WorkTracker
 from geo_activity_playground.core.time_conversion import convert_to_datetime_ns
 from geo_activity_playground.importers.activity_parsers import ActivityParseError
 from geo_activity_playground.importers.activity_parsers import read_activity
+from geo_activity_playground.importers.csv_parser import parse_csv
 
 
 logger = logging.getLogger(__name__)
@@ -48,9 +53,9 @@ EXPECTED_COLUMNS = [
     "Filename",
     "Athlete Weight",
     "Bike Weight",
-    "Elapsed Time.1",
+    "Elapsed Time",
     "Moving Time",
-    "Distance.1",
+    "Distance",
     "Max Speed",
     "Average Speed",
     "Elevation Gain",
@@ -63,14 +68,14 @@ EXPECTED_COLUMNS = [
     "Average Negative Grade",
     "Max Cadence",
     "Average Cadence",
-    "Max Heart Rate.1",
+    "Max Heart Rate",
     "Average Heart Rate",
     "Max Watts",
     "Average Watts",
     "Calories",
     "Max Temperature",
     "Average Temperature",
-    "Relative Effort.1",
+    "Relative Effort",
     "Total Work",
     "Number of Runs",
     "Uphill Time",
@@ -83,7 +88,7 @@ EXPECTED_COLUMNS = [
     "Power Count",
     "Prefer Perceived Exertion",
     "Perceived Relative Effort",
-    "Commute.1",
+    "Commute",
     "Total Weight Lifted",
     "From Upload",
     "Grade Adjusted Distance",
@@ -130,34 +135,41 @@ EXPECTED_COLUMNS = [
 ]
 
 
-def float_or_none(x: Union[float, str]) -> Optional[float]:
-    try:
-        return float(x)
-    except ValueError:
-        return None
+def float_with_comma_or_period(x: str) -> Optional[float]:
+    if len(x) == 0:
+        return 0
+
+    if "," in x:
+        x = x.replace(",", ".")
+    return float(x)
 
 
 def import_from_strava_checkout() -> None:
     checkout_path = pathlib.Path("Strava Export")
-    activities = pd.read_csv(checkout_path / "activities.csv")
+    with open(checkout_path / "activities.csv") as f:
+        rows = parse_csv(f.read())
+    header = rows[0]
+
+    if len(header) != len(EXPECTED_COLUMNS):
+        logger.error(
+            f"You are trying to import a Strava checkout where the `activities.csv` contains an unexpected header format. In order to import this, we need to map these to the English ones. Unfortunately Strava often changes the number of columns. Your file has {len(header)} but we expect {len(EXPECTED_COLUMNS)}. This means that the program needs to be updated to match the new Strava export format. Please go to https://github.com/martin-ueding/geo-activity-playground/issues and open a new issue and share the following output in the ticket:"
+        )
+        print(header)
+        sys.exit(1)
 
-    if activities.columns[0] == EXPECTED_COLUMNS[0]:
+    if header[0] == EXPECTED_COLUMNS[0]:
         dayfirst = False
-    if activities.columns[0] == "Aktivitäts-ID":
-        activities = pd.read_csv(checkout_path / "activities.csv", decimal=",")
-        if len(activities.columns) != len(EXPECTED_COLUMNS):
-            logger.error(
-                f"You are trying to import a Strava checkout where the `activities.csv` contains German column headers. In order to import this, we need to map these to the English ones. Unfortunately Strava has changed the number of columns. Your file has {len(activities.columns)} but we expect {len(EXPECTED_COLUMNS)}. This means that the program needs to be updated to match the new Strava export format. Please go to https://github.com/martin-ueding/geo-activity-playground/issues and open a new issue and share the following output in the ticket:"
-            )
-            print(activities.columns)
-            print(activities.dtypes)
-            sys.exit(1)
-        activities.columns = EXPECTED_COLUMNS
+    if header[0] == "Aktivitäts-ID":
+        header = EXPECTED_COLUMNS
         dayfirst = True
 
-    activities.index = activities["Activity ID"]
+    table = {
+        header[i]: [rows[r][i] for r in range(1, len(rows))] for i in range(len(header))
+    }
+    all_activity_ids = [int(value) for value in table["Activity ID"]]
+
     work_tracker = WorkTracker(work_tracker_path("import-strava-checkout-activities"))
-    activities_ids_to_parse = work_tracker.filter(activities["Activity ID"])
+    activities_ids_to_parse = work_tracker.filter(all_activity_ids)
     activities_ids_to_parse = [
         activity_id
         for activity_id in activities_ids_to_parse
@@ -166,16 +178,23 @@ def import_from_strava_checkout() -> None:
 
     for activity_id in tqdm(activities_ids_to_parse, desc="Import from Strava export"):
         work_tracker.mark_done(activity_id)
-        row = activities.loc[activity_id]
+        index = all_activity_ids.index(activity_id)
+        row = {column: table[column][index] for column in header}
+
         # Some manually recorded activities have no file name. Pandas reads that as a float. We skip those.
-        if isinstance(row["Filename"], float):
+        if not row["Filename"]:
             continue
+
+        start_datetime = dateutil.parser.parse(row["Activity Date"], dayfirst=dayfirst)
+
         activity_file = checkout_path / row["Filename"]
-        table_activity_meta = {
-            "calories": float_or_none(row["Calories"]),
+        table_activity_meta: ActivityMeta = {
+            "calories": float_with_comma_or_period(row["Calories"]),
             "commute": row["Commute"] == "true",
             "distance_km": row["Distance"],
-            "elapsed_time": datetime.timedelta(seconds=int(row["Elapsed Time"])),
+            "elapsed_time": datetime.timedelta(
+                seconds=float_with_comma_or_period(row["Elapsed Time"])
+            ),
             "equipment": str(
                 nan_as_none(row["Activity Gear"])
                 or nan_as_none(row["Bike"])
@@ -186,9 +205,8 @@ def import_from_strava_checkout() -> None:
             "id": activity_id,
             "name": row["Activity Name"],
             "path": str(activity_file),
-            "start": convert_to_datetime_ns(
-                dateutil.parser.parse(row["Activity Date"], dayfirst=dayfirst)
-            ),
+            "start": convert_to_datetime_ns(start_datetime),
+            "steps": float_with_comma_or_period(row["Total Steps"]),
         }
 
         time_series_path = (
@@ -219,6 +237,13 @@ def import_from_strava_checkout() -> None:
         with open(meta_path, "wb") as f:
             pickle.dump(table_activity_meta, f)
         time_series.to_parquet(time_series_path)
+
+        start_str = (
+            pd.Timestamp(table_activity_meta["start"]).to_pydatetime().isoformat() + "Z"
+        )
+        latest_start_str = get_state(strava_last_activity_date_path(), start_str)
+        set_state(strava_last_activity_date_path(), max(start_str, latest_start_str))
+
     work_tracker.close()
 
 

geo_activity_playground/importers/test_csv_parser.py

@@ -0,0 +1,49 @@
+import pytest
+
+from geo_activity_playground.importers.csv_parser import _parse_cell
+from geo_activity_playground.importers.csv_parser import _parse_line
+from geo_activity_playground.importers.csv_parser import parse_csv
+
+
+def test_parse_csv() -> None:
+    data = """
+A,B,C
+a,"b,b",c
+d,"e
+f",g
+"""
+    expected = [["A", "B", "C"], ["a", "b,b", "c"], ["d", "e\nf", "g"]]
+    assert parse_csv(data) == expected
+
+
+def test_parse_cell_plain() -> None:
+    assert _parse_cell("foo", 0) == ("foo", 3)
+
+
+def test_parse_cell_with_quotes() -> None:
+    assert _parse_cell('"foo"', 0) == ("foo", 5)
+
+
+def test_parse_cell_with_escape() -> None:
+    assert _parse_cell('"f\\"oo"', 0) == ('f"oo', 7)
+
+
+def test_parse_cell_with_newline() -> None:
+    assert _parse_cell('"f\noo"', 0) == ("f\noo", 6)
+
+
+def test_parse_cell_empty() -> None:
+    assert _parse_cell("", 0) == ("", 0)
+
+
+def test_parse_line() -> None:
+    assert _parse_line("a,b,c\n", 0) == (["a", "b", "c"], 6)
+
+
+def test_parse_line_empty_cell() -> None:
+    assert _parse_line("a,,c\n", 0) == (["a", "", "c"], 5)
+
+
+@pytest.mark.xfail
+def test_parse_line_empty_cell_at_end() -> None:
+    assert _parse_line("a,b,\n", 0) == (["a", "b", ""], 5)

geo_activity_playground/webui/activity/blueprint.py

@@ -8,19 +8,18 @@ from flask import Response
 from ...core.activities import ActivityRepository
 from ...explorer.tile_visits import TileVisitAccessor
 from .controller import ActivityController
+from geo_activity_playground.core.config import Config
 from geo_activity_playground.core.privacy_zones import PrivacyZone
 
 
 def make_activity_blueprint(
     repository: ActivityRepository,
     tile_visit_accessor: TileVisitAccessor,
-    privacy_zones: Collection[PrivacyZone],
+    config: Config,
 ) -> Blueprint:
     blueprint = Blueprint("activity", __name__, template_folder="templates")
 
-    activity_controller = ActivityController(
-        repository, tile_visit_accessor, privacy_zones
-    )
+    activity_controller = ActivityController(repository, tile_visit_accessor, config)
 
     @blueprint.route("/all")
     def all():

geo_activity_playground/webui/activity/controller.py

@@ -1,26 +1,24 @@
 import datetime
-import functools
 import io
 import logging
 import re
-from collections.abc import Collection
+from typing import Optional
 
 import altair as alt
 import geojson
 import matplotlib
-import matplotlib.pyplot as pl
 import numpy as np
 import pandas as pd
 from PIL import Image
 from PIL import ImageDraw
-from PIL import ImageFont
 
 from geo_activity_playground.core.activities import ActivityMeta
 from geo_activity_playground.core.activities import ActivityRepository
-from geo_activity_playground.core.activities import extract_heart_rate_zones
 from geo_activity_playground.core.activities import make_geojson_color_line
 from geo_activity_playground.core.activities import make_geojson_from_time_series
 from geo_activity_playground.core.activities import make_speed_color_bar
+from geo_activity_playground.core.config import Config
+from geo_activity_playground.core.heart_rate import HeartRateZoneComputer
 from geo_activity_playground.core.heatmap import add_margin_to_geo_bounds
 from geo_activity_playground.core.heatmap import build_map_from_tiles
 from geo_activity_playground.core.heatmap import GeoBounds
@@ -41,13 +39,13 @@ class ActivityController:
         self,
         repository: ActivityRepository,
         tile_visit_accessor: TileVisitAccessor,
-        privacy_zones: Collection[PrivacyZone],
+        config: Config,
     ) -> None:
         self._repository = repository
         self._tile_visit_accessor = tile_visit_accessor
-        self._privacy_zones = privacy_zones
+        self._config = config
+        self._heart_rate_zone_computer = HeartRateZoneComputer(config)
 
-    @functools.lru_cache()
     def render_activity(self, id: int) -> dict:
         activity = self._repository.get_activity_by_id(id)
 
@@ -82,18 +80,23 @@ class ActivityController:
             "time": activity["start"].time(),
             "new_tiles": new_tiles,
         }
-        if (heart_zones := extract_heart_rate_zones(time_series)) is not None:
-            result["heart_zones_plot"] = heartrate_zone_plot(heart_zones)
+        if (
+            heart_zones := _extract_heart_rate_zones(
+                time_series, self._heart_rate_zone_computer
+            )
+        ) is not None:
+            result["heart_zones_plot"] = heart_rate_zone_plot(heart_zones)
         if "altitude" in time_series.columns:
             result["altitude_time_plot"] = altitude_time_plot(time_series)
         if "heartrate" in time_series.columns:
-            result["heartrate_time_plot"] = heartrate_time_plot(time_series)
+            result["heartrate_time_plot"] = heart_rate_time_plot(time_series)
         return result
 
     def render_sharepic(self, id: int) -> bytes:
         activity = self._repository.get_activity_by_id(id)
         time_series = self._repository.get_time_series(id)
-        for privacy_zone in self._privacy_zones:
+        for coordinates in self._config.privacy_zones.values():
+            privacy_zone = PrivacyZone(coordinates)
             time_series = privacy_zone.filter_time_series(time_series)
         if len(time_series) == 0:
             time_series = self._repository.get_time_series(id)
@@ -280,7 +283,7 @@ def altitude_time_plot(time_series: pd.DataFrame) -> str:
     )
 
 
-def heartrate_time_plot(time_series: pd.DataFrame) -> str:
+def heart_rate_time_plot(time_series: pd.DataFrame) -> str:
     return (
         alt.Chart(time_series, title="Heart Rate")
         .mark_line()
@@ -294,7 +297,7 @@ def heartrate_time_plot(time_series: pd.DataFrame) -> str:
     )
 
 
-def heartrate_zone_plot(heart_zones: pd.DataFrame) -> str:
+def heart_rate_zone_plot(heart_zones: pd.DataFrame) -> str:
     return (
         alt.Chart(heart_zones, title="Heart Rate Zones")
         .mark_bar()
@@ -471,3 +474,26 @@ def make_sharepic(activity: ActivityMeta, time_series: pd.DataFrame) -> bytes:
     img.save(f, format="png")
     # pl.imsave(f, background, format="png")
     return bytes(f.getbuffer())
+
+
+def _extract_heart_rate_zones(
+    time_series: pd.DataFrame, heart_rate_zone_computer: HeartRateZoneComputer
+) -> Optional[pd.DataFrame]:
+    if "heartrate" not in time_series:
+        return
+
+    try:
+        zones = heart_rate_zone_computer.compute_zones(
+            time_series["heartrate"], time_series["time"].iloc[0].year
+        )
+    except RuntimeError:
+        return
+
+    df = pd.DataFrame({"heartzone": zones, "step": time_series["time"].diff()}).dropna()
+    duration_per_zone = df.groupby("heartzone").sum()["step"].dt.total_seconds() / 60
+    duration_per_zone.name = "minutes"
+    for i in range(6):
+        if i not in duration_per_zone:
+            duration_per_zone.loc[i] = 0.0
+    result = duration_per_zone.reset_index()
+    return result

geo_activity_playground/webui/activity/templates/activity/show.html.j2

@@ -121,11 +121,15 @@
     <div class="col-md-4">
         {{ vega_direct("heartrate_time_plot", heartrate_time_plot) }}
     </div>
-    {% if heart_zones_plot is defined %}
     <div class="col-md-4">
+        {% if heart_zones_plot is defined %}
         {{ vega_direct("heart_zones_plot", heart_zones_plot) }}
+        {% else %}
+        <p>Your activity has heart data, but this program doesn't know your maximum heart rate (or birth year) and
+            therefore cannot compute the heart rate zones. Go to the <a
+                href="{{ url_for('settings.heart_rate') }}">settings</a>.</p>
+        {% endif %}
     </div>
-    {% endif %}
 </div>
 {% endif %}
 

geo_activity_playground/webui/app.py

@@ -18,11 +18,11 @@ from .explorer.blueprint import make_explorer_blueprint
 from .heatmap.blueprint import make_heatmap_blueprint
 from .search_controller import SearchController
 from .square_planner.blueprint import make_square_planner_blueprint
-from .strava.blueprint import make_strava_blueprint
 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.privacy_zones import PrivacyZone
+from geo_activity_playground.core.config import ConfigAccessor
+from geo_activity_playground.webui.settings.blueprint import make_settings_blueprint
 
 
 def route_search(app: Flask, repository: ActivityRepository) -> None:
@@ -45,12 +45,6 @@ def route_start(app: Flask, repository: ActivityRepository) -> None:
         return render_template("home.html.j2", **entry_controller.render())
 
 
-def route_settings(app: Flask) -> None:
-    @app.route("/settings/")
-    def settings():
-        return render_template("settings.html.j2")
-
-
 def get_secret_key():
     secret_file = pathlib.Path("Cache/flask-secret.json")
     if secret_file.exists():
@@ -63,30 +57,28 @@ def get_secret_key():
     return secret
 
 
-def webui_main(
+def web_ui_main(
     repository: ActivityRepository,
     tile_visit_accessor: TileVisitAccessor,
-    config: dict,
+    config_accessor: ConfigAccessor,
     host: str,
     port: int,
 ) -> None:
-    app = Flask(__name__)
 
-    route_search(app, repository)
-    route_start(app, repository)
-    route_settings(app)
+    repository.reload()
 
+    app = Flask(__name__)
     app.config["UPLOAD_FOLDER"] = "Activities"
     app.secret_key = get_secret_key()
 
+    route_search(app, repository)
+    route_start(app, repository)
+
     app.register_blueprint(
         make_activity_blueprint(
             repository,
             tile_visit_accessor,
-            [
-                PrivacyZone(points)
-                for points in config.get("privacy_zones", {}).values()
-            ],
+            config_accessor(),
         ),
         url_prefix="/activity",
     )
@@ -95,14 +87,19 @@ def webui_main(
         make_eddington_blueprint(repository), url_prefix="/eddington"
     )
     app.register_blueprint(
-        make_equipment_blueprint(repository), url_prefix="/equipment"
+        make_equipment_blueprint(repository, config_accessor()), url_prefix="/equipment"
     )
     app.register_blueprint(
-        make_explorer_blueprint(repository, tile_visit_accessor), url_prefix="/explorer"
+        make_explorer_blueprint(repository, tile_visit_accessor, config_accessor),
+        url_prefix="/explorer",
     )
     app.register_blueprint(
         make_heatmap_blueprint(repository, tile_visit_accessor), url_prefix="/heatmap"
     )
+    app.register_blueprint(
+        make_settings_blueprint(config_accessor),
+        url_prefix="/settings",
+    )
     app.register_blueprint(
         make_square_planner_blueprint(repository, tile_visit_accessor),
         url_prefix="/square-planner",
@@ -111,21 +108,24 @@ def webui_main(
         make_summary_blueprint(repository),
         url_prefix="/summary",
     )
-    app.register_blueprint(
-        make_strava_blueprint(host, port),
-        url_prefix="/strava",
-    )
     app.register_blueprint(make_tile_blueprint(), url_prefix="/tile")
     app.register_blueprint(
-        make_upload_blueprint(repository, tile_visit_accessor, config),
+        make_upload_blueprint(repository, tile_visit_accessor, config_accessor()),
         url_prefix="/upload",
     )
 
     @app.context_processor
     def inject_global_variables() -> dict:
         return {
-            "version": importlib.metadata.version("geo-activity-playground"),
+            "version": _try_get_version(),
             "num_activities": len(repository),
         }
 
     app.run(host=host, port=port)
+
+
+def _try_get_version():
+    try:
+        return importlib.metadata.version("geo-activity-playground")
+    except importlib.metadata.PackageNotFoundError:
+        pass

geo_activity_playground/webui/eddington/controller.py

@@ -16,7 +16,7 @@ class EddingtonController:
         activities["day"] = [start.date() for start in activities["start"]]
 
         sum_per_day = activities.groupby("day").apply(
-            lambda group: int(sum(group["distance_km"]))
+            lambda group: int(sum(group["distance_km"])), include_groups=False
         )
         counts = dict(zip(*np.unique(sorted(sum_per_day), return_counts=True)))
         eddington = pd.DataFrame(

geo_activity_playground/webui/equipment/blueprint.py

@@ -3,12 +3,15 @@ from flask import render_template
 
 from ...core.activities import ActivityRepository
 from .controller import EquipmentController
+from geo_activity_playground.core.config import Config
 
 
-def make_equipment_blueprint(repository: ActivityRepository) -> Blueprint:
+def make_equipment_blueprint(
+    repository: ActivityRepository, config: Config
+) -> Blueprint:
     blueprint = Blueprint("equipment", __name__, template_folder="templates")
 
-    equipment_controller = EquipmentController(repository)
+    equipment_controller = EquipmentController(repository, config)
 
     @blueprint.route("/")
     def index():