geo-activity-playground 0.38.2__py3-none-any.whl → 0.39.1__py3-none-any.whl

geo_activity_playground/core/datamodel.py

@@ -0,0 +1,257 @@
+import datetime
+import logging
+from typing import Any
+from typing import TypedDict
+
+import numpy as np
+import pandas as pd
+import sqlalchemy
+import sqlalchemy as sa
+from flask_sqlalchemy import SQLAlchemy
+from sqlalchemy import ForeignKey
+from sqlalchemy import String
+from sqlalchemy.orm import DeclarativeBase
+from sqlalchemy.orm import Mapped
+from sqlalchemy.orm import mapped_column
+from sqlalchemy.orm import relationship
+
+from .config import Config
+from .paths import time_series_dir
+
+
+logger = logging.getLogger(__name__)
+
+
+class ActivityMeta(TypedDict):
+    average_speed_elapsed_kmh: float
+    average_speed_moving_kmh: float
+    calories: float
+    commute: bool
+    consider_for_achievements: bool
+    distance_km: float
+    elapsed_time: datetime.timedelta
+    elevation_gain: float
+    end_latitude: float
+    end_longitude: float
+    equipment: str
+    id: int
+    kind: str
+    moving_time: datetime.timedelta
+    name: str
+    path: str
+    start_latitude: float
+    start_longitude: float
+    start: np.datetime64
+    steps: int
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+DB = SQLAlchemy(model_class=Base)
+
+
+class Activity(DB.Model):
+    __tablename__ = "activities"
+
+    # Housekeeping data:
+    id: Mapped[int] = mapped_column(primary_key=True)
+    name: Mapped[str] = mapped_column(sa.String, nullable=False)
+    distance_km: Mapped[float] = mapped_column(sa.Float, nullable=False)
+
+    # Where it comes from:
+    path: Mapped[str] = mapped_column(sa.String, nullable=True)
+    upstream_id: Mapped[str] = mapped_column(sa.String, nullable=True)
+
+    # Crop data:
+    index_begin: Mapped[int] = mapped_column(sa.Integer, nullable=True)
+    index_end: Mapped[int] = mapped_column(sa.Integer, nullable=True)
+
+    # Temporal data:
+    start: Mapped[datetime.datetime] = mapped_column(sa.DateTime, nullable=True)
+    elapsed_time: Mapped[datetime.timedelta] = mapped_column(sa.Interval, nullable=True)
+    moving_time: Mapped[datetime.timedelta] = mapped_column(sa.Interval, nullable=True)
+
+    # Geographic data:
+    start_latitude: Mapped[float] = mapped_column(sa.Float, nullable=True)
+    start_longitude: Mapped[float] = mapped_column(sa.Float, nullable=True)
+    end_latitude: Mapped[float] = mapped_column(sa.Float, nullable=True)
+    end_longitude: Mapped[float] = mapped_column(sa.Float, nullable=True)
+
+    # Elevation data:
+    elevation_gain: Mapped[float] = mapped_column(sa.Float, nullable=True)
+    start_elevation: Mapped[float] = mapped_column(sa.Float, nullable=True)
+    end_elevation: Mapped[float] = mapped_column(sa.Float, nullable=True)
+
+    # Health data:
+    calories: Mapped[int] = mapped_column(sa.Integer, nullable=True)
+    steps: Mapped[int] = mapped_column(sa.Integer, nullable=True)
+
+    # Tile achievements:
+    num_new_tiles_14: Mapped[int] = mapped_column(sa.Integer, nullable=True)
+    num_new_tiles_17: Mapped[int] = mapped_column(sa.Integer, nullable=True)
+
+    # References to other tables:
+    equipment_id: Mapped[int] = mapped_column(
+        ForeignKey("equipments.id", name="equipment_id"), nullable=True
+    )
+    equipment: Mapped["Equipment"] = relationship(back_populates="activities")
+    kind_id: Mapped[int] = mapped_column(
+        ForeignKey("kinds.id", name="kind_id"), nullable=True
+    )
+    kind: Mapped["Kind"] = relationship(back_populates="activities")
+
+    def __getitem__(self, item) -> Any:
+        return self.to_dict()[item]
+
+    def __str__(self) -> str:
+        return f"{self.start} {self.name}"
+
+    @property
+    def average_speed_moving_kmh(self) -> float:
+        return self.distance_km / (self.moving_time.total_seconds() / 3_600)
+
+    @property
+    def average_speed_elapsed_kmh(self) -> float:
+        return self.distance_km / (self.elapsed_time.total_seconds() / 3_600)
+
+    @property
+    def raw_time_series(self) -> pd.DataFrame:
+        path = time_series_dir() / f"{self.id}.parquet"
+        try:
+            return pd.read_parquet(path)
+        except OSError as e:
+            logger.error(f"Error while reading {path}, deleting cache file …")
+            path.unlink(missing_ok=True)
+            raise
+
+    @property
+    def time_series(self) -> pd.DataFrame:
+        if self.index_begin or self.index_end:
+            return self.raw_time_series.iloc[
+                self.index_begin or 0 : self.index_end or -1
+            ]
+        else:
+            return self.raw_time_series
+
+    def to_dict(self) -> ActivityMeta:
+        equipment = self.equipment.name if self.equipment is not None else "Unknown"
+        kind = self.kind.name if self.kind is not None else "Unknown"
+        consider_for_achievements = (
+            self.kind.consider_for_achievements if self.kind is not None else True
+        )
+        return ActivityMeta(
+            id=self.id,
+            name=self.name,
+            path=self.path,
+            distance_km=self.distance_km,
+            start=self.start,
+            elapsed_time=self.elapsed_time,
+            moving_time=self.moving_time,
+            start_latitude=self.start_latitude,
+            start_longitude=self.start_longitude,
+            end_latitude=self.end_latitude,
+            end_longitude=self.end_longitude,
+            elevation_gain=self.elevation_gain,
+            start_elevation=self.start_elevation,
+            end_elevation=self.end_elevation,
+            calories=self.calories,
+            steps=self.steps,
+            num_new_tiles_14=self.num_new_tiles_14,
+            num_new_tiles_17=self.num_new_tiles_17,
+            equipment=equipment,
+            kind=kind,
+            average_speed_moving_kmh=self.average_speed_moving_kmh,
+            average_speed_elapsed_kmh=self.average_speed_elapsed_kmh,
+            consider_for_achievements=consider_for_achievements,
+        )
+
+
+class Equipment(DB.Model):
+    __tablename__ = "equipments"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+
+    name: Mapped[str] = mapped_column(String)
+    offset_km: Mapped[int] = mapped_column(sa.Integer, nullable=False, default=0)
+
+    activities: Mapped[list["Activity"]] = relationship(
+        back_populates="equipment", cascade="all, delete-orphan"
+    )
+    default_for_kinds: Mapped[list["Kind"]] = relationship(
+        back_populates="default_equipment", cascade="all, delete-orphan"
+    )
+
+    def __str__(self) -> str:
+        return f"{self.name} ({self.offset_km} km)"
+
+    __table_args__ = (sa.UniqueConstraint("name", name="equipments_name"),)
+
+
+class Kind(DB.Model):
+    __tablename__ = "kinds"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+
+    name: Mapped[str] = mapped_column(String)
+    consider_for_achievements: Mapped[bool] = mapped_column(
+        sa.Boolean, default=True, nullable=False
+    )
+
+    activities: Mapped[list["Activity"]] = relationship(
+        back_populates="kind", cascade="all, delete-orphan"
+    )
+    default_equipment_id: Mapped[int] = mapped_column(
+        ForeignKey("equipments.id", name="default_equipment_id"), nullable=True
+    )
+    default_equipment: Mapped["Equipment"] = relationship(
+        back_populates="default_for_kinds"
+    )
+
+    __table_args__ = (sa.UniqueConstraint("name", name="kinds_name"),)
+
+
+class SquarePlannerBookmark(DB.Model):
+    __tablename__ = "square_planner_bookmarks"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+
+    zoom: Mapped[int] = mapped_column(sa.Integer, nullable=False)
+    x: Mapped[int] = mapped_column(sa.Integer, nullable=False)
+    y: Mapped[int] = mapped_column(sa.Integer, nullable=False)
+    size: Mapped[int] = mapped_column(sa.Integer, nullable=False)
+    name: Mapped[str] = mapped_column(sa.String, nullable=False)
+
+    __table_args__ = (sa.UniqueConstraint("zoom", "x", "y", "size", name="kinds_name"),)
+
+
+def get_or_make_kind(name: str, config: Config) -> Kind:
+    kinds = DB.session.scalars(sqlalchemy.select(Kind).where(Kind.name == name)).all()
+    if kinds:
+        assert len(kinds) == 1, f"There must be only one kind with name '{name}'."
+        return kinds[0]
+    else:
+        kind = Kind(
+            name=name,
+            consider_for_achievements=name in config.kinds_without_achievements,
+        )
+        DB.session.add(kind)
+        return kind
+
+
+def get_or_make_equipment(name: str, config: Config) -> Equipment:
+    equipments = DB.session.scalars(
+        sqlalchemy.select(Equipment).where(Equipment.name == name)
+    ).all()
+    if equipments:
+        assert (
+            len(equipments) == 1
+        ), f"There must be only one equipment with name '{name}'."
+        return equipments[0]
+    else:
+        equipment = Equipment(
+            name=name, offset_km=config.equipment_offsets.get(name, 0)
+        )
+        DB.session.add(equipment)
+        return equipment

geo_activity_playground/core/enrichment.py

@@ -1,128 +1,126 @@
 import datetime
 import logging
 import pickle
-from typing import Any
 from typing import Optional
 
 import numpy as np
 import pandas as pd
+import sqlalchemy
 from tqdm import tqdm
 
-from geo_activity_playground.core.activities import ActivityMeta
-from geo_activity_playground.core.activities import make_activity_meta
-from geo_activity_playground.core.config import Config
-from geo_activity_playground.core.coordinates import get_distance
-from geo_activity_playground.core.paths import activity_enriched_meta_dir
-from geo_activity_playground.core.paths import activity_enriched_time_series_dir
-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.tiles import compute_tile_float
-from geo_activity_playground.core.time_conversion import convert_to_datetime_ns
+from .config import Config
+from .coordinates import get_distance
+from .datamodel import Activity
+from .datamodel import ActivityMeta
+from .datamodel import DB
+from .datamodel import get_or_make_equipment
+from .datamodel import get_or_make_kind
+from .paths import activity_extracted_meta_dir
+from .paths import activity_extracted_time_series_dir
+from .paths import time_series_dir
+from .tiles import compute_tile_float
+from .time_conversion import convert_to_datetime_ns
 
 logger = logging.getLogger(__name__)
 
 
-def enrich_activities(config: Config) -> None:
-    # Delete removed activities.
-    for enriched_metadata_path in activity_enriched_meta_dir().glob("*.pickle"):
-        if not (activity_extracted_meta_dir() / enriched_metadata_path.name).exists():
-            logger.warning(f"Deleting {enriched_metadata_path}")
-            enriched_metadata_path.unlink()
-    for enriched_time_series_path in activity_enriched_time_series_dir().glob(
-        "*.parquet"
-    ):
-        if not (
-            activity_extracted_time_series_dir() / enriched_time_series_path.name
-        ).exists():
-            logger.warning(f"Deleting {enriched_time_series_path}")
-            enriched_time_series_path.unlink()
-
-    # Get new metadata paths.
-    new_extracted_metadata_paths = []
-    for extracted_metadata_path in activity_extracted_meta_dir().glob("*.pickle"):
-        enriched_metadata_path = (
-            activity_enriched_meta_dir() / extracted_metadata_path.name
+def populate_database_from_extracted(config: Config) -> None:
+    available_ids = {
+        int(path.stem) for path in activity_extracted_meta_dir().glob("*.pickle")
+    }
+    present_ids = {
+        int(elem)
+        for elem in DB.session.scalars(sqlalchemy.select(Activity.upstream_id)).all()
+        if elem
+    }
+    new_ids = available_ids - present_ids
+
+    for upstream_id in tqdm(new_ids, desc="Importing new activities into database"):
+        extracted_metadata_path = (
+            activity_extracted_meta_dir() / f"{upstream_id}.pickle"
         )
-        if (
-            not enriched_metadata_path.exists()
-            or enriched_metadata_path.stat().st_mtime
-            < extracted_metadata_path.stat().st_mtime
-        ):
-            extracted_time_series_path = (
-                activity_extracted_time_series_dir()
-                / f"{extracted_metadata_path.stem}.parquet"
-            )
-            if extracted_time_series_path.exists():
-                new_extracted_metadata_paths.append(extracted_metadata_path)
-            else:
-                logger.error(
-                    f"Extracted activity metadata {extracted_metadata_path} is lacking the corresponding time series path {extracted_time_series_path}. Likely that is an activity without location data. Deleting this."
-                )
-                extracted_metadata_path.unlink()
-
-    for extracted_metadata_path in tqdm(
-        new_extracted_metadata_paths, desc="Enrich new activity data"
-    ):
-        # Read extracted data.
-        activity_id = extracted_metadata_path.stem
+        with open(extracted_metadata_path, "rb") as f:
+            extracted_metadata: ActivityMeta = pickle.load(f)
+
         extracted_time_series_path = (
-            activity_extracted_time_series_dir() / f"{activity_id}.parquet"
+            activity_extracted_time_series_dir() / f"{upstream_id}.parquet"
         )
         time_series = pd.read_parquet(extracted_time_series_path)
-        with open(extracted_metadata_path, "rb") as f:
-            extracted_metadata = pickle.load(f)
-
-        metadata = make_activity_meta()
-        metadata.update(extracted_metadata)
 
         # Skip activities that don't have geo information attached to them. This shouldn't happen, though.
         if "latitude" not in time_series.columns:
             logger.warning(
-                f"Activity {metadata} doesn't have latitude/longitude information. Ignoring this one."
+                f"Activity {upstream_id} doesn't have latitude/longitude information. Ignoring this one."
             )
             continue
 
-        # Rename kinds if needed.
-        if metadata["kind"] in config.kind_renames:
-            metadata["kind"] = config.kind_renames[metadata["kind"]]
-
-        # Enrich time series.
-        if metadata["kind"] in config.kinds_without_achievements:
-            metadata["consider_for_achievements"] = False
         time_series = _embellish_single_time_series(
-            time_series, metadata.get("start", None), config.time_diff_threshold_seconds
+            time_series,
+            extracted_metadata.get("start", None),
+            config.time_diff_threshold_seconds,
         )
-        metadata.update(_get_metadata_from_timeseries(time_series))
 
-        # Write enriched data.
-        enriched_metadata_path = activity_enriched_meta_dir() / f"{activity_id}.pickle"
-        enriched_time_series_path = (
-            activity_enriched_time_series_dir() / f"{activity_id}.parquet"
+        kind_name = extracted_metadata.get("kind", None)
+        if kind_name:
+            # Rename kinds if needed.
+            if kind_name in config.kind_renames:
+                kind_name = config.kind_renames[kind_name]
+            kind = get_or_make_kind(kind_name, config)
+        else:
+            kind = None
+
+        equipment_name = extracted_metadata.get("equipment", None)
+        if equipment_name:
+            equipment = get_or_make_equipment(equipment_name, config)
+        elif kind:
+            equipment = kind.default_equipment
+        else:
+            equipment = None
+
+        activity = Activity(
+            name=extracted_metadata.get("name", "Name Placeholder"),
+            distance_km=0,
+            equipment=equipment,
+            kind=kind,
+            calories=extracted_metadata.get("calories", None),
+            elevation_gain=extracted_metadata.get("elevation_gain", None),
+            steps=extracted_metadata.get("steps", None),
+            path=extracted_metadata.get("path", None),
+            upstream_id=upstream_id,
         )
-        with open(enriched_metadata_path, "wb") as f:
-            pickle.dump(metadata, f)
-        time_series.to_parquet(enriched_time_series_path)
 
+        update_via_time_series(activity, time_series)
 
-def _get_metadata_from_timeseries(timeseries: pd.DataFrame) -> ActivityMeta:
-    metadata = ActivityMeta()
+        DB.session.add(activity)
+        DB.session.commit()
 
-    # Extract some meta data from the time series.
-    metadata["start"] = timeseries["time"].iloc[0]
-    metadata["elapsed_time"] = timeseries["time"].iloc[-1] - timeseries["time"].iloc[0]
-    metadata["distance_km"] = timeseries["distance_km"].iloc[-1]
-    if "calories" in timeseries.columns:
-        metadata["calories"] = timeseries["calories"].iloc[-1]
-    metadata["moving_time"] = _compute_moving_time(timeseries)
+        enriched_time_series_path = time_series_dir() / f"{activity.id}.parquet"
+        time_series.to_parquet(enriched_time_series_path)
 
-    metadata["start_latitude"] = timeseries["latitude"].iloc[0]
-    metadata["end_latitude"] = timeseries["latitude"].iloc[-1]
-    metadata["start_longitude"] = timeseries["longitude"].iloc[0]
-    metadata["end_longitude"] = timeseries["longitude"].iloc[-1]
-    if "elevation_gain_cum" in timeseries.columns:
-        metadata["elevation_gain"] = timeseries["elevation_gain_cum"].iloc[-1]
 
-    return metadata
+def update_via_time_series(
+    activity: Activity, time_series: pd.DataFrame
+) -> ActivityMeta:
+    activity.start = time_series["time"].iloc[0]
+    activity.elapsed_time = time_series["time"].iloc[-1] - time_series["time"].iloc[0]
+    activity.distance_km = (
+        time_series["distance_km"].iloc[-1] - time_series["distance_km"].iloc[0]
+    )
+    if "calories" in time_series.columns:
+        activity.calories = (
+            time_series["calories"].iloc[-1] - time_series["calories"].iloc[0]
+        )
+    activity.moving_time = _compute_moving_time(time_series)
+
+    activity.start_latitude = time_series["latitude"].iloc[0]
+    activity.end_latitude = time_series["latitude"].iloc[-1]
+    activity.start_longitude = time_series["longitude"].iloc[0]
+    activity.end_longitude = time_series["longitude"].iloc[-1]
+    if "elevation_gain_cum" in time_series.columns:
+        elevation_gain_cum = time_series["elevation_gain_cum"].fillna(0)
+        activity.elevation_gain = (
+            elevation_gain_cum.iloc[-1] - elevation_gain_cum.iloc[0]
+        )
 
 
 def _compute_moving_time(time_series: pd.DataFrame) -> datetime.timedelta:

geo_activity_playground/core/heart_rate.py

@@ -1,10 +1,9 @@
 import datetime
 import math
-from typing import Optional
 
 import pandas as pd
 
-from geo_activity_playground.core.config import Config
+from .config import Config
 
 
 class HeartRateZoneComputer:

geo_activity_playground/core/parametric_plot.py

@@ -0,0 +1,101 @@
+import dataclasses
+from typing import Optional
+
+import altair as alt
+import pandas as pd
+
+
+@dataclasses.dataclass
+class ParametricPlotSpec:
+    mark: str
+    x: str
+    y: str
+    color: Optional[str]
+    shape: Optional[str]
+    size: Optional[str]
+    row: Optional[str]
+    column: Optional[str]
+
+
+MARKS = {"point": "Point", "circle": "Circle", "area": "Area", "bar": "Bar"}
+CONTINUOUS_VARIABLES = {
+    "distance_km": "Distance / km",
+    "sum(distance_km)": "Total distance / km",
+    "mean(distance_km)": "Average distance / km",
+    "start": "Date",
+    "hours": "Elapsed time / h",
+    "hours_moving": "Moving time / h",
+    "start_latitude": "Start latitude / °",
+    "start_longitude": "Start longitude / °",
+    "end_latitude": "End latitude / °",
+    "end_longitude": "End longitude / °",
+    "start_elevation": "Start elevation / m",
+    "end_elevation": "End elevation / m",
+    "elevation_gain": "Elevation gain / m",
+    "sum(elevation_gain)": "Total elevation gain / m",
+    "mean(elevation_gain)": "Average elevation gain / m",
+    "calories": "Energy / kcal",
+    "steps": "Steps",
+    "num_new_tiles_14": "New tiles 14",
+    "num_new_tiles_14": "New tiles 17",
+    "average_speed_moving_kmh": "Average moving speed / km/h",
+    "average_speed_elapsed_kmh": "Average elapsed speed / km/h",
+}
+DISCRETE_VARIABLES = {
+    "": "",
+    "year(start)": "Year",
+    "yearquarter(start)": "Year, Quarter",
+    "yearquartermonth(start)": "Year, Quarter, Month",
+    "yearmonth(start)": "Year, Month",
+    "quarter(start)": "Quarter",
+    "quartermonth(start)": "Quarter, Month",
+    "month(start)": "Month",
+    "date(start)": "Day of month",
+    "weekday(start)": "Day of week",
+    "iso_year": "ISO Year",
+    "week": "ISO Week",
+    "equipment": "Equipment",
+    "kind": "Activity kind",
+    "consider_for_achievements": "Consider for achievements",
+}
+ALL_VARIABLES = {**DISCRETE_VARIABLES, **CONTINUOUS_VARIABLES}
+
+
+def make_parametric_plot(df: pd.DataFrame, spec: ParametricPlotSpec) -> str:
+    chart = alt.Chart(df)
+
+    match spec.mark:
+        case "point":
+            chart = chart.mark_point()
+        case "circle":
+            chart = chart.mark_circle()
+        case "area":
+            chart = chart.mark_area()
+        case "bar":
+            chart = chart.mark_bar()
+
+    encodings = [
+        alt.X(spec.x, title=ALL_VARIABLES[spec.x]),
+        alt.Y(spec.y, title=ALL_VARIABLES[spec.y]),
+    ]
+    tooltips = [
+        alt.Tooltip(spec.x, title=ALL_VARIABLES[spec.x]),
+        alt.Tooltip(spec.y, title=ALL_VARIABLES[spec.y]),
+    ]
+    if spec.color:
+        encodings.append(alt.Color(spec.color, title=ALL_VARIABLES[spec.color]))
+        tooltips.append(alt.Tooltip(spec.color, title=ALL_VARIABLES[spec.color]))
+    if spec.shape:
+        encodings.append(alt.Shape(spec.shape, title=ALL_VARIABLES[spec.shape]))
+        tooltips.append(alt.Tooltip(spec.shape, title=ALL_VARIABLES[spec.shape]))
+    if spec.size:
+        encodings.append(alt.Size(spec.size, title=ALL_VARIABLES[spec.size]))
+        tooltips.append(alt.Tooltip(spec.size, title=ALL_VARIABLES[spec.size]))
+    if spec.row:
+        encodings.append(alt.Row(spec.row, title=ALL_VARIABLES[spec.row]))
+        tooltips.append(alt.Tooltip(spec.row, title=ALL_VARIABLES[spec.row]))
+    if spec.column:
+        encodings.append(alt.Column(spec.column, title=ALL_VARIABLES[spec.column]))
+        tooltips.append(alt.Tooltip(spec.column, title=ALL_VARIABLES[spec.column]))
+
+    return chart.encode(*encodings).interactive().to_json(format="vega")

geo_activity_playground/core/paths.py

@@ -1,11 +1,12 @@
-"""
-Paths within the playground and cache.
-"""
 import contextlib
 import functools
 import pathlib
 import typing
 
+"""
+Paths within the playground and cache.
+"""
+
 
 def dir_wrapper(path: pathlib.Path) -> typing.Callable[[], pathlib.Path]:
     def wrapper() -> pathlib.Path:
@@ -48,16 +49,13 @@ _tiles_per_time_series = _cache_dir / "Tiles" / "Tiles Per Time Series"
 
 _strava_api_dir = pathlib.Path("Strava API")
 _strava_dynamic_config_path = _strava_api_dir / "strava-client-id.json"
-
 _strava_last_activity_date_path = _cache_dir / "strava-last-activity-date.json"
-
 _new_config_file = pathlib.Path("config.json")
-
 _activity_meta_override_dir = pathlib.Path("Metadata Override")
+_time_series_dir = pathlib.Path("Time Series")
 
 
 cache_dir = dir_wrapper(_cache_dir)
-
 activity_extracted_dir = dir_wrapper(_activity_extracted_dir)
 activity_extracted_meta_dir = dir_wrapper(_activity_extracted_meta_dir)
 activity_extracted_time_series_dir = dir_wrapper(_activity_extracted_time_series_dir)
@@ -66,6 +64,7 @@ activity_enriched_time_series_dir = dir_wrapper(_activity_enriched_time_series_d
 tiles_per_time_series = dir_wrapper(_tiles_per_time_series)
 strava_api_dir = dir_wrapper(_strava_api_dir)
 activity_meta_override_dir = dir_wrapper(_activity_meta_override_dir)
+time_series_dir = dir_wrapper(_time_series_dir)
 
 activities_file = file_wrapper(_activities_file)
 strava_dynamic_config_path = file_wrapper(_strava_dynamic_config_path)