feat: add achievements and trophies endpoints, disable unavailable sensors

- Add extract_achievements_model() parser for profile/achievements.data
  endpoint. Counts earned vs total achievements and sums coins/XP from
  completed achievements across all categories.
- Add extract_trophies_model() parser for profile/trophies.data endpoint.
  Counts total trophies earned.
- Add AchievementsSummary and TrophiesSummary models.
- Add async_get_achievements() and async_get_trophies() API methods.
- Wire achievements and trophies into coordinator update cycle.
- Rewire career_achievements sensor to use dedicated achievements endpoint
  (was speculative via CareerStats; now uses real earned_achievements count).
- Rewire career_trophies sensor to use dedicated trophies endpoint.
- Disable 5 sensors with no known API endpoint (total_coins,
  career_total_distance, career_total_elevation, career_total_time,
  career_total_activities) with TODO(unavailable-endpoint) markers.
- Update CLI career command to fetch and display achievements/trophies
  from their dedicated endpoints.
- Add 12 new parser unit tests for achievements and trophies extraction.
- Update all affected tests (CLI, HA integration, sensor tests).

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: mikejhill

custom_components/rouvy/api.py

@@ -15,6 +15,7 @@
 
 from .api_client.errors import AuthenticationError, RouvyApiError
 from .api_client.models import (
+    AchievementsSummary,
     ActivitySummary,
     CareerStats,
     Challenge,
@@ -23,10 +24,12 @@
     FriendsSummary,
     Route,
     TrainingZones,
+    TrophiesSummary,
     UserProfile,
     WeeklyActivityStats,
 )
 from .api_client.parser import (
+    extract_achievements_model,
     extract_activities_model,
     extract_activity_stats_model,
     extract_career_model,
@@ -36,6 +39,7 @@
     extract_friends_model,
     extract_routes_model,
     extract_training_zones_model,
+    extract_trophies_model,
     extract_user_profile_model,
 )
 
@@ -245,6 +249,16 @@ async def async_get_career(self) -> CareerStats:
         text = await self._request("GET", "profile/career.data")
         return extract_career_model(text)
 
+    async def async_get_achievements(self) -> AchievementsSummary:
+        """Fetch achievements summary."""
+        text = await self._request("GET", "profile/achievements.data")
+        return extract_achievements_model(text)
+
+    async def async_get_trophies(self) -> TrophiesSummary:
+        """Fetch trophies summary."""
+        text = await self._request("GET", "profile/trophies.data")
+        return extract_trophies_model(text)
+
     async def async_register_challenge(self, slug: str) -> bool:
         """Register for a challenge by slug. Returns True on success."""
         import json as _json

custom_components/rouvy/api_client/__main__.py

@@ -23,6 +23,7 @@
 
 from ..api import RouvyAsyncApiClient
 from .models import (
+    AchievementsSummary,
     Activity,
     ActivitySummary,
     CareerStats,
@@ -32,6 +33,7 @@
     FriendsSummary,
     Route,
     TrainingZones,
+    TrophiesSummary,
     UserProfile,
     WeeklyActivityStats,
 )
@@ -459,23 +461,29 @@ async def _cmd_apps(client: RouvyAsyncApiClient, args: argparse.Namespace) -> No
 
 async def _cmd_career(client: RouvyAsyncApiClient, args: argparse.Namespace) -> None:
     career: CareerStats = await client.async_get_career()
+    achievements: AchievementsSummary = await client.async_get_achievements()
+    trophies: TrophiesSummary = await client.async_get_trophies()
 
     if args.json_output:
-        _json_out(_as_dict(career))
+        career_dict = _as_dict(career)
+        assert isinstance(career_dict, dict)  # single dataclass, never list
+        combined = {
+            **career_dict,
+            "achievements": _as_dict(achievements),
+            "trophies": _as_dict(trophies),
+        }
+        _json_out(combined)
         return
 
     print("=" * 70)
     print("CAREER STATS")
     print("=" * 70)
     print(f"  Level              : {career.level}")
     print(f"  Experience         : {career.experience_points:,} XP")
-    print(f"  Coins              : {career.coins:,}")
-    print(f"  Total Activities   : {career.total_activities:,}")
-    print(f"  Total Distance     : {career.total_distance_m / 1000.0:,.1f} km")
-    print(f"  Total Elevation    : {career.total_elevation_m:,.0f} m")
-    print(f"  Total Time         : {_format_time(career.total_time_seconds)}")
-    print(f"  Achievements       : {career.total_achievements}")
-    print(f"  Trophies           : {career.total_trophies}")
+    earned = achievements.earned_achievements
+    total = achievements.total_achievements
+    print(f"  Achievements       : {earned}/{total}")
+    print(f"  Trophies           : {trophies.total_trophies}")
     print("=" * 70)
 
 

custom_components/rouvy/api_client/models.py

@@ -164,17 +164,40 @@ class Event:
 
 @dataclass(frozen=True)
 class CareerStats:
-    """Career progression stats from the profile/career endpoint."""
+    """Career progression stats from the profile/career endpoint.
 
+    Only ``experience_points`` and ``level`` are available from the career
+    endpoint.  Lifetime totals (distance, elevation, time, activities) and
+    coins are **not** exposed by any known Rouvy API endpoint and are left
+    at their defaults.
+    """
+
+    experience_points: int = 0
+    level: int = 0
+    # TODO(unavailable-endpoint): lifetime totals not exposed by Rouvy API
     total_distance_m: float = 0.0
     total_elevation_m: float = 0.0
     total_time_seconds: int = 0
     total_activities: int = 0
+    # TODO(unavailable-endpoint): total coins not exposed by Rouvy API
+    coins: int = 0
+
+
+@dataclass(frozen=True)
+class AchievementsSummary:
+    """Summary of user achievements from profile/achievements.data."""
+
     total_achievements: int = 0
+    earned_achievements: int = 0
+    total_coins_from_achievements: int = 0
+    total_xp_from_achievements: int = 0
+
+
+@dataclass(frozen=True)
+class TrophiesSummary:
+    """Summary of user trophies from profile/trophies.data."""
+
     total_trophies: int = 0
-    experience_points: int = 0
-    level: int = 0
-    coins: int = 0
 
 
 @dataclass(frozen=True)
@@ -203,4 +226,6 @@ class RouvyCoordinatorData:
     favorite_routes: list[Route] = field(default_factory=list)
     upcoming_events: list[Event] = field(default_factory=list)
     career: CareerStats | None = None
+    achievements: AchievementsSummary | None = None
+    trophies: TrophiesSummary | None = None
     friends: FriendsSummary | None = None

custom_components/rouvy/api_client/parser.py

@@ -23,6 +23,7 @@
 
 if TYPE_CHECKING:
     from .models import (
+        AchievementsSummary,
         ActivitySummary,
         ActivityTypeStats,
         CareerStats,
@@ -32,6 +33,7 @@
         FriendsSummary,
         Route,
         TrainingZones,
+        TrophiesSummary,
         UserProfile,
         WeeklyActivityStats,
     )
@@ -934,3 +936,78 @@ def extract_friends_model(response_text: str) -> FriendsSummary:
             online += 1
 
     return FriendsSummary(total_friends=total, online_friends=online)
+
+
+def extract_achievements_model(response_text: str) -> AchievementsSummary:
+    """Extract an AchievementsSummary from a profile/achievements.data response.
+
+    The achievements endpoint returns a dict keyed by category (e.g.
+    ``workoutsAchievements``, ``distanceAchievements``). Each category is a
+    list of achievement objects, each having a ``goal`` with ``isCompleted``,
+    plus ``coins`` and ``experience`` reward fields.
+    """
+    from .models import AchievementsSummary
+
+    if not response_text or not response_text.strip():
+        return AchievementsSummary()
+
+    decoder = TurboStreamDecoder()
+    decoded = decoder.decode(response_text)
+    array_data: list[Any] = decoded if isinstance(decoded, list) else []
+
+    achievements = _find_key_value(array_data, "achievements")
+    if not isinstance(achievements, dict):
+        return AchievementsSummary()
+
+    total = 0
+    earned = 0
+    coins = 0
+    xp = 0
+
+    for category_items in achievements.values():
+        resolved_items = _resolve_index(category_items, decoder.index_map)
+        if not isinstance(resolved_items, list):
+            continue
+        for raw_item in resolved_items:
+            item = _resolve_index(raw_item, decoder.index_map)
+            if not isinstance(item, dict):
+                continue
+            total += 1
+            goal = item.get("goal", {})
+            if isinstance(goal, dict) and goal.get("isCompleted"):
+                earned += 1
+                coins += _safe_int(item.get("coins", 0))
+                xp += _safe_int(item.get("experience", 0))
+
+    return AchievementsSummary(
+        total_achievements=total,
+        earned_achievements=earned,
+        total_coins_from_achievements=coins,
+        total_xp_from_achievements=xp,
+    )
+
+
+def extract_trophies_model(response_text: str) -> TrophiesSummary:
+    """Extract a TrophiesSummary from a profile/trophies.data response.
+
+    The trophies endpoint returns a ``trophies`` key containing a list of
+    trophy objects (each with routeId, type, value, etc.). We count the total.
+    """
+    from .models import TrophiesSummary
+
+    if not response_text or not response_text.strip():
+        return TrophiesSummary()
+
+    decoder = TurboStreamDecoder()
+    decoded = decoder.decode(response_text)
+    array_data: list[Any] = decoded if isinstance(decoded, list) else []
+
+    trophies = _find_key_value(array_data, "trophies")
+    if not isinstance(trophies, list):
+        return TrophiesSummary()
+
+    # Resolve the list; each item is a trophy object
+    resolved = _resolve_index(trophies, decoder.index_map)
+    count = len(resolved) if isinstance(resolved, list) else len(trophies)
+
+    return TrophiesSummary(total_trophies=count)

custom_components/rouvy/coordinator.py

@@ -109,6 +109,20 @@ async def _async_update_data(self) -> RouvyCoordinatorData:
             except Exception:
                 _LOGGER.debug("Failed to fetch career stats, continuing without", exc_info=True)
 
+            # Fetch achievements summary
+            achievements = None
+            try:
+                achievements = await client.async_get_achievements()
+            except Exception:
+                _LOGGER.debug("Failed to fetch achievements, continuing without", exc_info=True)
+
+            # Fetch trophies summary
+            trophies = None
+            try:
+                trophies = await client.async_get_trophies()
+            except Exception:
+                _LOGGER.debug("Failed to fetch trophies, continuing without", exc_info=True)
+
             # Fetch friends summary
             friends = None
             try:
@@ -128,6 +142,8 @@ async def _async_update_data(self) -> RouvyCoordinatorData:
                 favorite_routes=favorite_routes,
                 upcoming_events=upcoming_events,
                 career=career,
+                achievements=achievements,
+                trophies=trophies,
                 friends=friends,
             )
         except AuthenticationError as err:

custom_components/rouvy/sensor.py

@@ -310,60 +310,66 @@ class RouvySensorDescription(SensorEntityDescription):
         state_class=SensorStateClass.TOTAL,
         value_fn=lambda d: d.career.experience_points if d.career else None,
     ),
-    RouvySensorDescription(
-        key="total_coins",
-        translation_key="total_coins",
-        state_class=SensorStateClass.TOTAL,
-        value_fn=lambda d: d.career.coins if d.career else None,
-    ),
-    RouvySensorDescription(
-        key="career_total_distance",
-        translation_key="career_total_distance",
-        native_unit_of_measurement=UnitOfLength.KILOMETERS,
-        device_class=SensorDeviceClass.DISTANCE,
-        state_class=SensorStateClass.TOTAL,
-        suggested_display_precision=1,
-        value_fn=lambda d: (
-            round(d.career.total_distance_m / 1000, 1)
-            if d.career and d.career.total_distance_m
-            else None
-        ),
-    ),
-    RouvySensorDescription(
-        key="career_total_elevation",
-        translation_key="career_total_elevation",
-        native_unit_of_measurement=UnitOfLength.METERS,
-        device_class=SensorDeviceClass.DISTANCE,
-        state_class=SensorStateClass.TOTAL,
-        suggested_display_precision=0,
-        value_fn=lambda d: round(d.career.total_elevation_m) if d.career else None,
-    ),
-    RouvySensorDescription(
-        key="career_total_time",
-        translation_key="career_total_time",
-        native_unit_of_measurement=UnitOfTime.HOURS,
-        device_class=SensorDeviceClass.DURATION,
-        state_class=SensorStateClass.TOTAL,
-        suggested_display_precision=1,
-        value_fn=lambda d: round(d.career.total_time_seconds / 3600, 1) if d.career else None,
-    ),
-    RouvySensorDescription(
-        key="career_total_activities",
-        translation_key="career_total_activities",
-        state_class=SensorStateClass.TOTAL,
-        value_fn=lambda d: d.career.total_activities if d.career else None,
-    ),
+    # TODO(unavailable-endpoint): total coins not exposed by any known Rouvy API endpoint
+    # RouvySensorDescription(
+    #     key="total_coins",
+    #     translation_key="total_coins",
+    #     state_class=SensorStateClass.TOTAL,
+    #     value_fn=lambda d: d.career.coins if d.career else None,
+    # ),
+    # TODO(unavailable-endpoint): lifetime distance not exposed by any known Rouvy API endpoint
+    # RouvySensorDescription(
+    #     key="career_total_distance",
+    #     translation_key="career_total_distance",
+    #     native_unit_of_measurement=UnitOfLength.KILOMETERS,
+    #     device_class=SensorDeviceClass.DISTANCE,
+    #     state_class=SensorStateClass.TOTAL,
+    #     suggested_display_precision=1,
+    #     value_fn=lambda d: (
+    #         round(d.career.total_distance_m / 1000, 1)
+    #         if d.career and d.career.total_distance_m
+    #         else None
+    #     ),
+    # ),
+    # TODO(unavailable-endpoint): lifetime elevation not exposed by any known Rouvy API endpoint
+    # RouvySensorDescription(
+    #     key="career_total_elevation",
+    #     translation_key="career_total_elevation",
+    #     native_unit_of_measurement=UnitOfLength.METERS,
+    #     device_class=SensorDeviceClass.DISTANCE,
+    #     state_class=SensorStateClass.TOTAL,
+    #     suggested_display_precision=0,
+    #     value_fn=lambda d: round(d.career.total_elevation_m) if d.career else None,
+    # ),
+    # TODO(unavailable-endpoint): lifetime time not exposed by any known Rouvy API endpoint
+    # RouvySensorDescription(
+    #     key="career_total_time",
+    #     translation_key="career_total_time",
+    #     native_unit_of_measurement=UnitOfTime.HOURS,
+    #     device_class=SensorDeviceClass.DURATION,
+    #     state_class=SensorStateClass.TOTAL,
+    #     suggested_display_precision=1,
+    #     value_fn=lambda d: round(d.career.total_time_seconds / 3600, 1) if d.career else None,
+    # ),
+    # TODO(unavailable-endpoint): lifetime activities not exposed by Rouvy API
+    # RouvySensorDescription(
+    #     key="career_total_activities",
+    #     translation_key="career_total_activities",
+    #     state_class=SensorStateClass.TOTAL,
+    #     value_fn=lambda d: d.career.total_activities if d.career else None,
+    # ),
+    # Achievement and trophy sensors (from dedicated endpoints)
     RouvySensorDescription(
         key="career_achievements",
         translation_key="career_achievements",
         state_class=SensorStateClass.TOTAL,
-        value_fn=lambda d: d.career.total_achievements if d.career else None,
+        value_fn=lambda d: d.achievements.earned_achievements if d.achievements else None,
     ),
     RouvySensorDescription(
         key="career_trophies",
         translation_key="career_trophies",
         state_class=SensorStateClass.TOTAL,
-        value_fn=lambda d: d.career.total_trophies if d.career else None,
+        value_fn=lambda d: d.trophies.total_trophies if d.trophies else None,
     ),
     # Friends sensors
     RouvySensorDescription(