geo-activity-playground 1.2.0__tar.gz → 1.3.0__tar.gz

{geo_activity_playground-1.2.0 → geo_activity_playground-1.3.0}/PKG-INFO

@@ -1,14 +1,13 @@
 Metadata-Version: 2.1
 Name: geo-activity-playground
-Version: 1.2.0
+Version: 1.3.0
 Summary: Analysis of geo data activities like rides, runs or hikes.
 License: MIT
 Author: Martin Ueding
 Author-email: mu@martin-ueding.de
-Requires-Python: >=3.10,<3.14
+Requires-Python: >=3.11,<3.14
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
@@ -16,6 +15,7 @@ Requires-Dist: Pillow (>=11.0.0,<12.0.0)
 Requires-Dist: alembic (>=1.15.2,<2.0.0)
 Requires-Dist: altair (>=5.5.0,<6.0.0)
 Requires-Dist: appdirs (>=1.4.4,<2.0.0)
+Requires-Dist: boto3 (>=1.38.45,<2.0.0)
 Requires-Dist: charset-normalizer (>=3.3.2,<4.0.0)
 Requires-Dist: coloredlogs (>=15.0.1,<16.0.0)
 Requires-Dist: exifread (>=3.2.0,<4.0.0)
@@ -24,15 +24,19 @@ Requires-Dist: flask (>=3.0.0,<4.0.0)
 Requires-Dist: flask-alembic (>=3.1.1,<4.0.0)
 Requires-Dist: flask-sqlalchemy (>=3.1.1,<4.0.0)
 Requires-Dist: geojson (>=3.0.1,<4.0.0)
+Requires-Dist: geotiff (>=0.2.10,<0.3.0)
 Requires-Dist: gpxpy (>=1.5.0,<2.0.0)
+Requires-Dist: imagecodecs (>=2025.3.30,<2026.0.0)
 Requires-Dist: jinja2 (>=3.1.2,<4.0.0)
 Requires-Dist: matplotlib (>=3.10.1,<4.0.0)
+Requires-Dist: numcodecs (<0.15.0)
 Requires-Dist: numpy (>=2.2.3,<3.0.0)
 Requires-Dist: openpyxl (>=3.1.5,<4.0.0)
 Requires-Dist: pandas (>=2.2.3,<3.0.0)
 Requires-Dist: pyarrow (>=19.0.1,<20.0.0)
 Requires-Dist: python-dateutil (>=2.8.2,<3.0.0)
 Requires-Dist: requests (>=2.28.1,<3.0.0)
+Requires-Dist: scipy (>=1.16.0,<2.0.0)
 Requires-Dist: shapely (>=2.0.5,<3.0.0)
 Requires-Dist: sqlalchemy (>=2.0.40,<3.0.0)
 Requires-Dist: stravalib (>=2.0,<3.0)

geo_activity_playground-1.3.0/geo_activity_playground/alembic/versions/85fe0348e8a2_add_time_series_uuid_field.py

@@ -0,0 +1,28 @@
+from typing import Sequence
+from typing import Union
+
+import sqlalchemy as sa
+from alembic import op
+
+
+# revision identifiers, used by Alembic.
+revision: str = "85fe0348e8a2"
+down_revision: Union[str, None] = "f2f50843be2d"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("activities", schema=None) as batch_op:
+        batch_op.add_column(sa.Column("time_series_uuid", sa.String(), nullable=True))
+
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("activities", schema=None) as batch_op:
+        batch_op.drop_column("time_series_uuid")
+
+    # ### end Alembic commands ###

geo_activity_playground-1.3.0/geo_activity_playground/alembic/versions/f2f50843be2d_make_all_fields_in_activity_nullable.py

@@ -0,0 +1,34 @@
+from typing import Sequence
+from typing import Union
+
+import sqlalchemy as sa
+from alembic import op
+
+
+# revision identifiers, used by Alembic.
+revision: str = "f2f50843be2d"
+down_revision: Union[str, None] = "dc8073871da7"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("activities", schema=None) as batch_op:
+        batch_op.add_column(sa.Column("iana_timezone", sa.String(), nullable=True))
+        batch_op.add_column(sa.Column("start_country", sa.String(), nullable=True))
+        batch_op.alter_column("name", existing_type=sa.VARCHAR(), nullable=True)
+        batch_op.alter_column("distance_km", existing_type=sa.FLOAT(), nullable=True)
+
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("activities", schema=None) as batch_op:
+        batch_op.alter_column("distance_km", existing_type=sa.FLOAT(), nullable=False)
+        batch_op.alter_column("name", existing_type=sa.VARCHAR(), nullable=False)
+        batch_op.drop_column("start_country")
+        batch_op.drop_column("iana_timezone")
+
+    # ### end Alembic commands ###

{geo_activity_playground-1.2.0 → geo_activity_playground-1.3.0}/geo_activity_playground/core/coordinates.py

@@ -1,4 +1,7 @@
+import typing
+
 import numpy as np
+import pandas as pd
 
 
 class Bounds:
@@ -15,7 +18,15 @@ class Bounds:
         return (self.x_min < x < self.x_max) and (self.y_min < y < self.y_max)
 
 
-def get_distance(lat_1: float, lon_1: float, lat_2: float, lon_2: float) -> float:
+FloatOrSeries = typing.TypeVar("FloatOrSeries", float, np.ndarray, pd.Series)
+
+
+def get_distance(
+    lat_1: FloatOrSeries,
+    lon_1: FloatOrSeries,
+    lat_2: FloatOrSeries,
+    lon_2: FloatOrSeries,
+) -> FloatOrSeries:
     """
     https://en.wikipedia.org/wiki/Haversine_formula
     """

geo_activity_playground-1.3.0/geo_activity_playground/core/copernicus_dem.py

@@ -0,0 +1,95 @@
+import functools
+import math
+import pathlib
+from typing import Optional
+
+import boto3
+import botocore.config
+import botocore.exceptions
+import geotiff
+import numpy as np
+from scipy.interpolate import RegularGridInterpolator
+
+from .paths import USER_CACHE_DIR
+
+
+def s3_path(lat: int, lon: int) -> pathlib.Path:
+    lat_str = f"N{(lat):02d}" if lat >= 0 else f"S{(-lat):02d}"
+    lon_str = f"E{(lon):03d}" if lon >= 0 else f"W{(-lon):03d}"
+    result = (
+        USER_CACHE_DIR
+        / "Copernicus DEM"
+        / f"Copernicus_DSM_COG_30_{lat_str}_00_{lon_str}_00_DEM.tif"
+    )
+
+    result.parent.mkdir(exist_ok=True)
+    return result
+
+
+def ensure_copernicus_file(p: pathlib.Path) -> None:
+    if p.exists():
+        return
+    s3 = boto3.client(
+        "s3", config=botocore.config.Config(signature_version=botocore.UNSIGNED)
+    )
+    try:
+        s3.download_file("copernicus-dem-90m", f"{p.stem}/{p.name}", p)
+    except botocore.exceptions.ClientError as e:
+        pass
+
+
+@functools.lru_cache(9)
+def get_elevation_arrays(p: pathlib.Path) -> Optional[np.ndarray]:
+    ensure_copernicus_file(p)
+    if not p.exists():
+        return None
+    gt = geotiff.GeoTiff(p)
+    a = np.array(gt.read())
+    lon_array, lat_array = gt.get_coord_arrays()
+    return np.stack([a, lat_array, lon_array], axis=0)
+
+
+@functools.lru_cache(1)
+def get_interpolator(lat: int, lon: int) -> Optional[RegularGridInterpolator]:
+    arrays = get_elevation_arrays(s3_path(lat, lon))
+    # If we don't have data for the current center, we cannot do anything.
+    if arrays is None:
+        return None
+
+    # # Take a look at the neighbors. If all 8 neighbor grid cells are present, we can
+    # neighbor_shapes = [
+    #     get_elevation_arrays(s3_path(lat + lat_offset, lon + lon_offset)).shape
+    #     for lon_offset in [-1, 0, 1]
+    #     for lat_offset in [-1, 0, 1]
+    #     if get_elevation_arrays(s3_path(lat + lat_offset, lon + lon_offset)) is not None
+    # ]
+    # if len(neighbor_shapes) == 9 and len(set(neighbor_shapes)) == 1:
+    #     arrays = np.concatenate(
+    #         [
+    #             np.concatenate(
+    #                 [
+    #                     get_elevation_arrays(
+    #                         s3_path(lat + lat_offset, lon + lon_offset)
+    #                     )
+    #                     for lon_offset in [-1, 0, 1]
+    #                 ],
+    #                 axis=2,
+    #             )
+    #             for lat_offset in [1, 0, -1]
+    #         ],
+    #         axis=1,
+    #     )
+    lat_labels = arrays[1, :, 0]
+    lon_labels = arrays[2, 0, :]
+
+    return RegularGridInterpolator(
+        (lat_labels, lon_labels), arrays[0], bounds_error=False, fill_value=None
+    )
+
+
+def get_elevation(lat: float, lon: float) -> float:
+    interpolator = get_interpolator(math.floor(lat), math.floor(lon))
+    if interpolator is not None:
+        return float(interpolator((lat, lon)))
+    else:
+        return 0.0

{geo_activity_playground-1.2.0 → geo_activity_playground-1.3.0}/geo_activity_playground/core/datamodel.py

@@ -1,7 +1,11 @@
 import datetime
 import json
 import logging
+import os
 import pathlib
+import shutil
+import uuid
+import zoneinfo
 from typing import Any
 from typing import Optional
 from typing import TypedDict
@@ -49,6 +53,7 @@ class ActivityMeta(TypedDict):
     calories: float
     commute: bool
     consider_for_achievements: bool
+    copernicus_elevation_gain: float
     distance_km: float
     elapsed_time: datetime.timedelta
     elevation_gain: float
@@ -85,27 +90,36 @@ class Activity(DB.Model):
 
     # 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)
+    name: Mapped[Optional[str]] = mapped_column(sa.String, nullable=True)
+    distance_km: Mapped[Optional[float]] = mapped_column(sa.Float, nullable=True)
+    time_series_uuid: Mapped[Optional[str]] = mapped_column(sa.String, nullable=True)
 
     # Where it comes from:
-    path: Mapped[str] = mapped_column(sa.String, nullable=True)
-    upstream_id: Mapped[str] = mapped_column(sa.String, nullable=True)
+    path: Mapped[Optional[str]] = mapped_column(sa.String, nullable=True)
+    upstream_id: Mapped[Optional[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)
+    start: Mapped[Optional[datetime.datetime]] = mapped_column(
+        sa.DateTime, nullable=True
+    )
+    iana_timezone: Mapped[Optional[str]] = mapped_column(sa.String, nullable=True)
+    elapsed_time: Mapped[Optional[datetime.timedelta]] = mapped_column(
+        sa.Interval, nullable=True
+    )
+    moving_time: Mapped[Optional[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)
+    start_country: Mapped[Optional[str]] = mapped_column(sa.String, nullable=True)
 
     # Elevation data:
     elevation_gain: Mapped[float] = mapped_column(sa.Float, nullable=True)
@@ -143,30 +157,36 @@ class Activity(DB.Model):
 
     @property
     def average_speed_moving_kmh(self) -> Optional[float]:
-        if self.moving_time:
+        if self.distance_km and self.moving_time:
             return self.distance_km / (self.moving_time.total_seconds() / 3_600)
         else:
             return None
 
     @property
     def average_speed_elapsed_kmh(self) -> Optional[float]:
-        if self.elapsed_time:
+        if self.distance_km and self.elapsed_time:
             return self.distance_km / (self.elapsed_time.total_seconds() / 3_600)
         else:
             return None
 
+    @property
+    def time_series_path(self) -> pathlib.Path:
+        return TIME_SERIES_DIR() / f"{self.time_series_uuid}.parquet"
+
     @property
     def raw_time_series(self) -> pd.DataFrame:
-        path = TIME_SERIES_DIR() / f"{self.id}.parquet"
         try:
-            time_series = pd.read_parquet(path)
+            time_series = pd.read_parquet(self.time_series_path)
             if "altitude" in time_series.columns:
                 time_series.rename(columns={"altitude": "elevation"}, inplace=True)
             return time_series
         except OSError as e:
-            logger.error(f"Error while reading {path}.")
+            logger.error(f"Error while reading {self.time_series_path}.")
             raise
 
+    def replace_time_series(self, time_series: pd.DataFrame) -> None:
+        time_series.to_parquet(self.time_series_path)
+
     @property
     def time_series(self) -> pd.DataFrame:
         if self.index_begin or self.index_end:
@@ -201,6 +221,15 @@ class Activity(DB.Model):
         ]:
             path.unlink(missing_ok=True)
 
+    @property
+    def start_local_tz(self) -> Optional[datetime.datetime]:
+        if self.start and self.iana_timezone:
+            return self.start.replace(
+                microsecond=0, tzinfo=zoneinfo.ZoneInfo("UTC")
+            ).astimezone(zoneinfo.ZoneInfo(self.iana_timezone))
+        else:
+            return self.start
+
 
 class Tag(DB.Model):
     __tablename__ = "tags"
@@ -329,7 +358,6 @@ def get_or_make_equipment(name: str, config: Config) -> Equipment:
         equipment = Equipment(
             name=name, offset_km=config.equipment_offsets.get(name, 0)
         )
-        DB.session.add(equipment)
         return equipment
 
 
@@ -356,7 +384,7 @@ class Kind(DB.Model):
     __table_args__ = (sa.UniqueConstraint("name", name="kinds_name"),)
 
 
-def get_or_make_kind(name: str, config: Config) -> Kind:
+def get_or_make_kind(name: str) -> 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}'."
@@ -364,9 +392,8 @@ def get_or_make_kind(name: str, config: Config) -> Kind:
     else:
         kind = Kind(
             name=name,
-            consider_for_achievements=name in config.kinds_without_achievements,
+            consider_for_achievements=True,
         )
-        DB.session.add(kind)
         return kind
 
 

geo_activity_playground-1.3.0/geo_activity_playground/core/enrichment.py

@@ -0,0 +1,274 @@
+import datetime
+import logging
+import zoneinfo
+from typing import Callable
+
+import numpy as np
+import pandas as pd
+
+from .config import Config
+from .coordinates import get_distance
+from .copernicus_dem import get_elevation
+from .datamodel import Activity
+from .datamodel import DB
+from .missing_values import some
+from .tiles import compute_tile_float
+from .time_conversion import get_country_timezone
+
+logger = logging.getLogger(__name__)
+
+
+def enrichment_set_timezone(
+    activity: Activity, time_series: pd.DataFrame, config: Config
+) -> bool:
+    assert (
+        len(time_series) > 0
+    ), f"You cannot import an activity without points. {activity=}"
+    latitude, longitude = time_series[["latitude", "longitude"]].iloc[0].to_list()
+    if activity.iana_timezone is None or activity.start_country is None:
+        country, tz_str = get_country_timezone(latitude, longitude)
+        activity.iana_timezone = tz_str
+        activity.start_country = country
+        return True
+    else:
+        return False
+
+
+def enrichment_normalize_time(
+    activity: Activity, time_series: pd.DataFrame, config: Config
+) -> bool:
+    # Routes (as opposed to tracks) don't have time information. We cannot do anything with time here.
+    if (
+        "time" in time_series.columns
+        and pd.isna(time_series["time"]).all()
+        and not pd.api.types.is_datetime64_any_dtype(time_series["time"].dtype)
+    ):
+        time_series["time"] = pd.NaT
+        return True
+
+    changed = False
+    tz_utc = zoneinfo.ZoneInfo("UTC")
+    # If the time is naive, assume that it is UTC.
+    if time_series["time"].dt.tz is None:
+        time_series["time"] = time_series["time"].dt.tz_localize(tz_utc)
+        changed = True
+
+    if time_series["time"].dt.tz.utcoffset(None) != tz_utc.utcoffset(None):
+        time_series["time"] = time_series["time"].dt.tz_convert(tz_utc)
+        changed = True
+
+    if not pd.api.types.is_dtype_equal(
+        time_series["time"].dtype, "datetime64[ns, UTC]"
+    ):
+        time_series["time"] = time_series["time"].dt.tz_convert(tz_utc)
+        changed = True
+
+    assert pd.api.types.is_dtype_equal(
+        time_series["time"].dtype, "datetime64[ns, UTC]"
+    ), (
+        time_series["time"].dtype,
+        time_series["time"].iloc[0],
+    )
+
+    new_start = some(time_series["time"].iloc[0])
+    if new_start != activity.start:
+        activity.start = new_start
+        changed = True
+
+    new_elapsed_time = some(time_series["time"].iloc[-1] - time_series["time"].iloc[0])
+    if new_elapsed_time != activity.elapsed_time:
+        activity.elapsed_time = new_elapsed_time
+        changed = True
+
+    return changed
+
+
+def enrichment_rename_altitude(
+    activity: Activity, time_series: pd.DataFrame, config: Config
+) -> bool:
+    if "altitude" in time_series.columns:
+        time_series.rename(columns={"altitude": "elevation"}, inplace=True)
+        return True
+    else:
+        return False
+
+
+def enrichment_compute_tile_xy(
+    activity: Activity, time_series: pd.DataFrame, config: Config
+) -> bool:
+    if "x" not in time_series.columns:
+        x, y = compute_tile_float(time_series["latitude"], time_series["longitude"], 0)
+        time_series["x"] = x
+        time_series["y"] = y
+        return True
+    else:
+        return False
+
+
+def enrichment_copernicus_elevation(
+    activity: Activity, time_series: pd.DataFrame, config: Config
+) -> bool:
+    if "copernicus_elevation" not in time_series.columns:
+        time_series["copernicus_elevation"] = [
+            get_elevation(lat, lon)
+            for lat, lon in zip(time_series["latitude"], time_series["longitude"])
+        ]
+        return True
+    else:
+        return False
+
+
+def enrichment_elevation_gain(
+    activity: Activity, time_series: pd.DataFrame, config: Config
+) -> bool:
+    if (
+        "elevation" in time_series.columns
+        or "copernicus_elevation" in time_series.columns
+    ) and "elevation_gain_cum" not in time_series.columns:
+        elevation = (
+            time_series["elevation"]
+            if "elevation" in time_series.columns
+            else time_series["copernicus_elevation"]
+        )
+        elevation_diff = elevation.diff()
+        elevation_diff = elevation_diff.ewm(span=5, min_periods=5).mean()
+        elevation_diff.loc[elevation_diff.abs() > 30] = 0
+        elevation_diff.loc[elevation_diff < 0] = 0
+        time_series["elevation_gain_cum"] = elevation_diff.cumsum().fillna(0)
+
+        activity.elevation_gain = (
+            time_series["elevation_gain_cum"].iloc[-1]
+            - time_series["elevation_gain_cum"].iloc[0]
+        )
+        return True
+    else:
+        return False
+
+
+def enrichment_add_calories(
+    activity: Activity, time_series: pd.DataFrame, config: Config
+) -> bool:
+    if activity.calories is None and "calories" in time_series.columns:
+        activity.calories = (
+            time_series["calories"].iloc[-1] - time_series["calories"].iloc[0]
+        )
+        return True
+    else:
+        return False
+
+
+def enrichment_distance(
+    activity: Activity, time_series: pd.DataFrame, config: Config
+) -> bool:
+    changed = False
+
+    distances = get_distance(
+        time_series["latitude"].shift(1),
+        time_series["longitude"].shift(1),
+        time_series["latitude"],
+        time_series["longitude"],
+    ).fillna(0.0)
+
+    if config.time_diff_threshold_seconds:
+        time_diff = (
+            time_series["time"] - time_series["time"].shift(1)
+        ).dt.total_seconds()
+        jump_indices = time_diff >= config.time_diff_threshold_seconds
+        distances.loc[jump_indices] = 0.0
+
+    if "distance_km" not in time_series.columns:
+        time_series["distance_km"] = pd.Series(np.cumsum(distances)) / 1000
+        changed = True
+
+    if "speed" not in time_series.columns:
+        time_series["speed"] = (
+            time_series["distance_km"].diff()
+            / (time_series["time"].diff().dt.total_seconds() + 1e-3)
+            * 3600
+        )
+        changed = True
+
+    potential_jumps = (time_series["speed"] > 40) & (time_series["speed"].diff() > 10)
+    if np.any(potential_jumps):
+        time_series.replace(time_series.loc[~potential_jumps])
+        changed = True
+
+    if "segment_id" not in time_series.columns:
+        if config.time_diff_threshold_seconds:
+            time_series["segment_id"] = np.cumsum(jump_indices)
+        else:
+            time_series["segment_id"] = 0
+        changed = True
+
+    new_distance_km = (
+        time_series["distance_km"].iloc[-1] - time_series["distance_km"].iloc[0]
+    )
+    if new_distance_km != activity.distance_km:
+        activity.distance_km = new_distance_km
+        changed = True
+
+    return changed
+
+
+def enrichment_moving_time(
+    activity: Activity, time_series: pd.DataFrame, config: Config
+) -> bool:
+    def moving_time(group) -> datetime.timedelta:
+        selection = group["speed"] > 1.0
+        time_diff = group["time"].diff().loc[selection]
+        return time_diff.sum()
+
+    new_moving_time = (
+        time_series.groupby("segment_id").apply(moving_time, include_groups=False).sum()
+    )
+    if new_moving_time != activity.moving_time:
+        activity.moving_time = new_moving_time
+        return True
+    else:
+        return False
+
+
+def enrichment_copy_latlon(
+    activity: Activity, time_series: pd.DataFrame, config: Config
+) -> bool:
+    if activity.start_latitude is None:
+        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]
+        return True
+    else:
+        return False
+
+
+enrichments: list[Callable[[Activity, pd.DataFrame, Config], bool]] = [
+    enrichment_set_timezone,
+    enrichment_normalize_time,
+    enrichment_rename_altitude,
+    enrichment_compute_tile_xy,
+    enrichment_copernicus_elevation,
+    enrichment_elevation_gain,
+    enrichment_add_calories,
+    enrichment_distance,
+    enrichment_moving_time,
+    enrichment_copy_latlon,
+]
+
+
+def apply_enrichments(
+    activity: Activity, time_series: pd.DataFrame, config: Config
+) -> bool:
+    was_changed = False
+    for enrichment in enrichments:
+        was_changed |= enrichment(activity, time_series, config)
+    return was_changed
+
+
+def update_and_commit(
+    activity: Activity, time_series: pd.DataFrame, config: Config
+) -> None:
+    changed = apply_enrichments(activity, time_series, config)
+    if changed:
+        activity.replace_time_series(time_series)
+    DB.session.add(activity)
+    DB.session.commit()

{geo_activity_playground-1.2.0 → geo_activity_playground-1.3.0}/geo_activity_playground/core/paths.py

@@ -3,10 +3,18 @@ import functools
 import pathlib
 import typing
 
+import appdirs
+
 """
 Paths within the playground and cache.
 """
 
+APPDIRS = appdirs.AppDirs(appname="Geo Activity Playground", appauthor="Martin Ueding")
+
+USER_CACHE_DIR = pathlib.Path(APPDIRS.user_cache_dir)
+USER_CONFIG_DIR = pathlib.Path(APPDIRS.user_config_dir)
+USER_DATA_DIR = pathlib.Path(APPDIRS.user_data_dir)
+
 
 def dir_wrapper(path: pathlib.Path) -> typing.Callable[[], pathlib.Path]:
     def wrapper() -> pathlib.Path: