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

geo_activity_playground/alembic/script.py.mako

@@ -1,10 +1,4 @@
-"""${message}
 
-Revision ID: ${up_revision}
-Revises: ${down_revision | comma,n}
-Create Date: ${create_date}
-
-"""
 from typing import Sequence, Union
 
 from alembic import op

geo_activity_playground/alembic/versions/da2cba03b71d_add_photos.py

@@ -0,0 +1,40 @@
+from typing import Sequence
+from typing import Union
+
+import sqlalchemy as sa
+from alembic import op
+
+
+# revision identifiers, used by Alembic.
+revision: str = "da2cba03b71d"
+down_revision: Union[str, None] = "38882503dc7c"
+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! ###
+    op.create_table(
+        "photos",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("filename", sa.String(), nullable=False),
+        sa.Column("time", sa.DateTime(), nullable=False),
+        sa.Column("latitude", sa.Float(), nullable=False),
+        sa.Column("longitude", sa.Float(), nullable=False),
+        sa.Column("activity_id", sa.Integer(), nullable=False),
+        sa.ForeignKeyConstraint(["activity_id"], ["activities.id"], name="activity_id"),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    with op.batch_alter_table("tags", schema=None) as batch_op:
+        batch_op.create_unique_constraint("tags_tag", ["tag"])
+
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("tags", schema=None) as batch_op:
+        batch_op.drop_constraint("tags_tag", type_="unique")
+
+    op.drop_table("photos")
+    # ### end Alembic commands ###

geo_activity_playground/alembic/versions/script.py.mako

@@ -1,4 +1,10 @@
+"""${message}
 
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
 from typing import Sequence, Union
 
 from alembic import op

geo_activity_playground/core/activities.py

@@ -2,6 +2,7 @@ import datetime
 import functools
 import logging
 from collections.abc import Callable
+from collections.abc import Sequence
 from typing import Any
 from typing import Optional
 
@@ -21,20 +22,11 @@ from geo_activity_playground.core.datamodel import query_activity_meta
 logger = logging.getLogger(__name__)
 
 
-def make_activity_meta() -> ActivityMeta:
-    return ActivityMeta(
-        calories=None,
-        commute=False,
-        consider_for_achievements=True,
-        equipment="Unknown",
-        kind="Unknown",
-        steps=None,
-    )
-
-
 class ActivityRepository:
     def __len__(self) -> int:
-        return len(self.get_activity_ids())
+        return DB.session.scalars(
+            sqlalchemy.select(sqlalchemy.func.count()).select_from(Activity)
+        ).one()
 
     def has_activity(self, activity_id: int) -> bool:
         return bool(
@@ -52,14 +44,14 @@ class ActivityRepository:
         else:
             return None
 
-    def get_activity_ids(self, only_achievements: bool = False) -> list[int]:
+    def get_activity_ids(self, only_achievements: bool = False) -> Sequence[int]:
         query = sqlalchemy.select(Activity.id)
         if only_achievements:
             query = query.where(Kind.consider_for_achievements)
-        result = DB.session.scalars(query).all()
+        result = DB.session.scalars(query.order_by(Activity.start)).all()
         return result
 
-    def iter_activities(self, new_to_old=True, drop_na=False) -> list[Activity]:
+    def iter_activities(self, new_to_old=True, drop_na=False) -> Sequence[Activity]:
         query = sqlalchemy.select(Activity)
         if drop_na:
             query = query.where(Activity.start.is_not(None))

geo_activity_playground/core/datamodel.py

@@ -1,6 +1,7 @@
 import datetime
 import json
 import logging
+import pathlib
 from typing import Any
 from typing import Optional
 from typing import TypedDict
@@ -117,8 +118,9 @@ class Activity(DB.Model):
         secondary=activity_tag_association_table, back_populates="activities"
     )
 
-    def __getitem__(self, item) -> Any:
-        return self.to_dict()[item]
+    photos: Mapped[list["Photo"]] = relationship(
+        back_populates="activity", cascade="all, delete-orphan"
+    )
 
     def __str__(self) -> str:
         return f"{self.start} {self.name}"
@@ -127,11 +129,15 @@ class Activity(DB.Model):
     def average_speed_moving_kmh(self) -> Optional[float]:
         if 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:
             return self.distance_km / (self.elapsed_time.total_seconds() / 3_600)
+        else:
+            return None
 
     @property
     def raw_time_series(self) -> pd.DataFrame:
@@ -154,38 +160,6 @@ class Activity(DB.Model):
         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 Tag(DB.Model):
     __tablename__ = "tags"
@@ -199,7 +173,18 @@ class Tag(DB.Model):
     )
 
 
-def query_activity_meta() -> pd.DataFrame:
+def get_or_make_tag(tag: str) -> Tag:
+    tags = DB.session.scalars(sqlalchemy.select(Tag).where(Tag.tag == tag)).all()
+    if tags:
+        assert len(tags) == 1, f"There must be only one tag with name '{tag}'."
+        return tags[0]
+    else:
+        tag = Tag(tag=tag)
+        DB.session.add(tag)
+        return tag
+
+
+def query_activity_meta(clauses: list = []) -> pd.DataFrame:
     rows = DB.session.execute(
         sqlalchemy.select(
             Activity.id,
@@ -226,31 +211,33 @@ def query_activity_meta() -> pd.DataFrame:
         )
         .join(Activity.equipment)
         .join(Activity.kind)
+        .where(*clauses)
         .order_by(Activity.start)
     ).all()
     df = pd.DataFrame(rows)
 
-    for old, new in [
-        ("elapsed_time", "average_speed_elapsed_kmh"),
-        ("moving_time", "average_speed_moving_kmh"),
-    ]:
-        df[new] = pd.NA
-        mask = df[old].dt.total_seconds() > 0
-        df.loc[mask, new] = df.loc[mask, "distance_km"] / (
-            df.loc[mask, old].dt.total_seconds() / 3_600
-        )
-
-    df["date"] = df["start"].dt.date
-    df["year"] = df["start"].dt.year
-    df["month"] = df["start"].dt.month
-    df["day"] = df["start"].dt.day
-    df["week"] = df["start"].dt.isocalendar().week
-    df["day_of_week"] = df["start"].dt.day_of_week
-    df["iso_year"] = df["start"].dt.isocalendar().year
-    df["hours"] = df["elapsed_time"].dt.total_seconds() / 3_600
-    df["hours_moving"] = df["moving_time"].dt.total_seconds() / 3_600
-
-    df.index = df["id"]
+    if len(df):
+        for old, new in [
+            ("elapsed_time", "average_speed_elapsed_kmh"),
+            ("moving_time", "average_speed_moving_kmh"),
+        ]:
+            df[new] = pd.NA
+            mask = df[old].dt.total_seconds() > 0
+            df.loc[mask, new] = df.loc[mask, "distance_km"] / (
+                df.loc[mask, old].dt.total_seconds() / 3_600
+            )
+
+        df["date"] = df["start"].dt.date
+        df["year"] = df["start"].dt.year
+        df["month"] = df["start"].dt.month
+        df["day"] = df["start"].dt.day
+        df["week"] = df["start"].dt.isocalendar().week
+        df["day_of_week"] = df["start"].dt.day_of_week
+        df["iso_year"] = df["start"].dt.isocalendar().year
+        df["hours"] = df["elapsed_time"].dt.total_seconds() / 3_600
+        df["hours_moving"] = df["moving_time"].dt.total_seconds() / 3_600
+
+        df.index = df["id"]
 
     return df
 
@@ -276,6 +263,23 @@ class Equipment(DB.Model):
     __table_args__ = (sa.UniqueConstraint("name", name="equipments_name"),)
 
 
+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
+
+
 class Kind(DB.Model):
     __tablename__ = "kinds"
 
@@ -299,20 +303,6 @@ class Kind(DB.Model):
     __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:
@@ -327,21 +317,18 @@ def get_or_make_kind(name: str, config: Config) -> 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
+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"),)
 
 
 class PlotSpec(DB.Model):
@@ -383,3 +370,22 @@ class PlotSpec(DB.Model):
         return json.dumps(
             {key: getattr(self, key) for key in self.FIELDS if getattr(self, key)}
         )
+
+
+class Photo(DB.Model):
+    __tablename__ = "photos"
+    id: Mapped[int] = mapped_column(primary_key=True)
+
+    filename: Mapped[str] = mapped_column(sa.String, nullable=False)
+    time: Mapped[datetime.datetime] = mapped_column(sa.DateTime, nullable=False)
+    latitude: Mapped[float] = mapped_column(sa.Float, nullable=False)
+    longitude: Mapped[float] = mapped_column(sa.Float, nullable=False)
+
+    activity_id: Mapped[int] = mapped_column(
+        ForeignKey("activities.id", name="activity_id"), nullable=False
+    )
+    activity: Mapped["Activity"] = relationship(back_populates="photos")
+
+    @property
+    def path(self) -> pathlib.Path:
+        return pathlib.Path(self.filename)

geo_activity_playground/core/enrichment.py

@@ -15,6 +15,7 @@ from .datamodel import ActivityMeta
 from .datamodel import DB
 from .datamodel import get_or_make_equipment
 from .datamodel import get_or_make_kind
+from .missing_values import some
 from .paths import activity_extracted_meta_dir
 from .paths import activity_extracted_time_series_dir
 from .paths import time_series_dir
@@ -82,9 +83,9 @@ def populate_database_from_extracted(config: Config) -> None:
             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),
+            calories=some(extracted_metadata.get("calories", None)),
+            elevation_gain=some(extracted_metadata.get("elevation_gain", None)),
+            steps=some(extracted_metadata.get("steps", None)),
             path=extracted_metadata.get("path", None),
             upstream_id=upstream_id,
         )
@@ -92,7 +93,13 @@ def populate_database_from_extracted(config: Config) -> None:
         update_via_time_series(activity, time_series)
 
         DB.session.add(activity)
-        DB.session.commit()
+        try:
+            DB.session.commit()
+        except sqlalchemy.exc.StatementError:
+            logger.error(
+                f"Could not insert the following activity into the database: {vars(activity)=}"
+            )
+            raise
 
         enriched_time_series_path = time_series_dir() / f"{activity.id}.parquet"
         time_series.to_parquet(enriched_time_series_path)
@@ -101,8 +108,10 @@ def populate_database_from_extracted(config: Config) -> None:
 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.start = some(time_series["time"].iloc[0])
+    activity.elapsed_time = some(
+        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]
     )

geo_activity_playground/core/meta_search.py

@@ -2,21 +2,33 @@ import dataclasses
 import datetime
 import re
 import urllib.parse
+from collections.abc import Sequence
 from typing import Optional
 
 import dateutil.parser
 import numpy as np
 import pandas as pd
+import sqlalchemy
+
+from .datamodel import Activity
+from .datamodel import DB
+from .datamodel import Equipment
+from .datamodel import Kind
+from .datamodel import query_activity_meta
+from .datamodel import Tag
 
 
 @dataclasses.dataclass
 class SearchQuery:
-    equipment: list[str] = dataclasses.field(default_factory=list)
-    kind: list[str] = dataclasses.field(default_factory=list)
+    equipment: list[Equipment] = dataclasses.field(default_factory=list)
+    kind: list[Kind] = dataclasses.field(default_factory=list)
+    tag: list[Tag] = dataclasses.field(default_factory=list)
     name: Optional[str] = None
     name_case_sensitive: bool = False
     start_begin: Optional[datetime.date] = None
     start_end: Optional[datetime.date] = None
+    distance_km_min: Optional[float] = None
+    distance_km_max: Optional[float] = None
 
     def __str__(self) -> str:
         bits = []
@@ -25,10 +37,14 @@ class SearchQuery:
         if self.equipment:
             bits.append(
                 "equipment is "
-                + (" or ".join(f"“{equipment}”" for equipment in self.equipment))
+                + (" or ".join(f"“{equipment.name}”" for equipment in self.equipment))
             )
         if self.kind:
-            bits.append("kind is " + (" or ".join(f"“{kind}”" for kind in self.kind)))
+            bits.append(
+                "kind is " + (" or ".join(f"“{kind.name}”" for kind in self.kind))
+            )
+        if self.tag:
+            bits.append("tag is " + (" or ".join(f"“{tag.tag}”" for tag in self.tag)))
         if self.start_begin:
             bits.append(f"after “{self.start_begin.isoformat()}”")
         if self.start_end:
@@ -43,27 +59,38 @@ class SearchQuery:
             or self.name
             or self.start_begin
             or self.start_end
+            or self.tag
+            or self.distance_km_min
+            or self.distance_km_max
         )
 
     def to_primitives(self) -> dict:
         return {
-            "equipment": self.equipment,
-            "kind": self.kind,
+            "equipment": [equipment.id for equipment in self.equipment],
+            "kind": [kind.id for kind in self.kind],
+            "tag": [tag.id for tag in self.tag],
             "name": self.name or "",
             "name_case_sensitive": self.name_case_sensitive,
             "start_begin": _format_optional_date(self.start_begin),
             "start_end": _format_optional_date(self.start_end),
+            "distance_km_min": self.distance_km_min,
+            "distance_km_max": self.distance_km_max,
         }
 
     @classmethod
     def from_primitives(cls, d: dict) -> "SearchQuery":
         return cls(
-            equipment=d.get("equipment", []),
-            kind=d.get("kind", []),
+            equipment=[
+                DB.session.get_one(Equipment, id) for id in d.get("equipment", [])
+            ],
+            kind=[DB.session.get_one(Kind, id) for id in d.get("kind", [])],
+            tag=[DB.session.get_one(Tag, id) for id in d.get("tag", [])],
             name=d.get("name", None),
             name_case_sensitive=d.get("name_case_sensitive", False),
             start_begin=_parse_date_or_none(d.get("start_begin", None)),
             start_end=_parse_date_or_none(d.get("start_end", None)),
+            distance_km_min=d.get("distance_km_min", None),
+            distance_km_max=d.get("distance_km_max", None),
         )
 
     def to_jinja(self) -> dict:
@@ -74,9 +101,11 @@ class SearchQuery:
     def to_url_str(self) -> str:
         variables = []
         for equipment in self.equipment:
-            variables.append(("equipment", equipment))
+            variables.append(("equipment", equipment.id))
         for kind in self.kind:
-            variables.append(("kind", kind))
+            variables.append(("kind", kind.id))
+        for tag in self.tag:
+            variables.append(("tag", tag.id))
         if self.name:
             variables.append(("name", self.name))
         if self.name_case_sensitive:
@@ -85,6 +114,10 @@ class SearchQuery:
             variables.append(("start_begin", self.start_begin.isoformat()))
         if self.start_end:
             variables.append(("start_end", self.start_end.isoformat()))
+        if self.distance_km_min:
+            variables.append(("distance_km_min", self.distance_km_min))
+        if self.distance_km_max:
+            variables.append(("distance_km_max", self.distance_km_max))
 
         return "&".join(
             f"{key}={urllib.parse.quote_plus(value)}" for key, value in variables
@@ -94,36 +127,47 @@ class SearchQuery:
 def apply_search_query(
     activity_meta: pd.DataFrame, search_query: SearchQuery
 ) -> pd.DataFrame:
-    mask = _make_mask(activity_meta.index, True)
+
+    filter_clauses = []
 
     if search_query.equipment:
-        mask &= _filter_column(activity_meta["equipment"], search_query.equipment)
+        filter_clauses.append(
+            sqlalchemy.or_(
+                *[
+                    Activity.equipment == equipment
+                    for equipment in search_query.equipment
+                ]
+            )
+        )
+
     if search_query.kind:
-        mask &= _filter_column(activity_meta["kind"], search_query.kind)
-    if search_query.name:
-        mask &= pd.Series(
-            [
-                bool(
-                    re.search(
-                        search_query.name,
-                        activity_name,
-                        0 if search_query.name_case_sensitive else re.IGNORECASE,
-                    )
-                )
-                for activity_name in activity_meta["name"]
-            ],
-            index=activity_meta.index,
+        filter_clauses.append(
+            sqlalchemy.or_(*[Activity.kind == kind for kind in search_query.kind])
+        )
+
+    if search_query.tag:
+        filter_clauses.append(
+            sqlalchemy.or_(*[Activity.tags.contains(tag) for tag in search_query.tag])
         )
-    if search_query.start_begin is not None:
-        start_begin = datetime.datetime.combine(
-            search_query.start_begin, datetime.time.min
+
+    if search_query.name:
+        filter_clauses.append(
+            Activity.name.contains(search_query.name)
+            if search_query.name_case_sensitive
+            else Activity.name.icontains(search_query.name)
         )
-        mask &= start_begin <= activity_meta["start"]
-    if search_query.start_end is not None:
-        start_end = datetime.datetime.combine(search_query.start_end, datetime.time.max)
-        mask &= activity_meta["start"] <= start_end
 
-    return activity_meta.loc[mask]
+    if search_query.start_begin:
+        filter_clauses.append(Activity.start <= search_query.start_begin)
+    if search_query.start_end:
+        filter_clauses.append(Activity.start < search_query.start_end)
+
+    if search_query.distance_km_min:
+        filter_clauses.append(Activity.distance_km >= search_query.distance_km_min)
+    if search_query.distance_km_max:
+        filter_clauses.append(Activity.distance_km <= search_query.distance_km_max)
+
+    return query_activity_meta(filter_clauses)
 
 
 def _format_optional_date(date: Optional[datetime.date]) -> str:

geo_activity_playground/core/missing_values.py

@@ -0,0 +1,16 @@
+from typing import Any
+from typing import Optional
+
+import numpy as np
+import pandas as pd
+
+
+def some(value: Any) -> Optional[Any]:
+    if value is None:
+        return None
+    elif np.isnan(value):
+        return None
+    elif pd.isna(value):
+        return None
+    else:
+        return value

geo_activity_playground/core/paths.py

@@ -53,6 +53,7 @@ _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")
+_photos_dir = pathlib.Path("Photos")
 
 
 cache_dir = dir_wrapper(_cache_dir)
@@ -65,6 +66,7 @@ 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)
+PHOTOS_DIR = dir_wrapper(_photos_dir)
 
 activities_file = file_wrapper(_activities_file)
 strava_dynamic_config_path = file_wrapper(_strava_dynamic_config_path)

geo_activity_playground/core/test_missing_values.py

@@ -0,0 +1,19 @@
+import numpy as np
+
+from .missing_values import some
+
+
+def test_none() -> None:
+    assert some(None) == None
+
+
+def test_nan() -> None:
+    assert some(np.nan) == None
+
+
+def test_float() -> None:
+    assert some(1.0) == 1.0
+
+
+def test_integer() -> None:
+    assert some(1) == 1

geo_activity_playground/explorer/tile_visits.py

@@ -176,7 +176,7 @@ def _process_activity(
             activity_tiles["time"],
             zip(activity_tiles["tile_x"], activity_tiles["tile_y"]),
         ):
-            if activity["consider_for_achievements"]:
+            if activity.kind.consider_for_achievements:
                 if tile not in tile_state["tile_visits"][zoom]:
                     new_tile_history_soa["activity_id"].append(activity_id)
                     new_tile_history_soa["time"].append(time)