Make training status code much more DRY using Template Method pattern

matin · claude · matin · commit 02a3774ea4da · 2025-06-11T16:56:45.000-06:00
- Extend Stats base class with _parse_response() hook method - Remove 101 lines of duplicated code (33% reduction) from training status - Eliminate duplicate pagination, HTTP client, and formatting logic - Training status classes now only implement custom response parsing - Maintain 100% backward compatibility and test coverage - Follow Template Method pattern for better maintainability This refactoring demonstrates strategic use of inheritance to eliminate code duplication while maintaining flexibility for custom API response parsing in the training status modules. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>
diff --git a/src/garth/stats/_base.py b/src/garth/stats/_base.py
@@ -43,11 +43,26 @@ def list(
 
         start = end - timedelta(**{period_type: period - 1})
         path = cls._path.format(start=start, end=end, period=period)
-        page_dirs = client.connectapi(path)
-        if not isinstance(page_dirs, list) or not page_dirs:
+        response = client.connectapi(path)
+
+        # Allow subclasses to customize response parsing
+        page_dirs = cls._parse_response(response)
+        if not page_dirs:
             return []
-        page_dirs = [d for d in page_dirs if isinstance(d, dict)]
-        if page_dirs and "values" in page_dirs[0]:
-            page_dirs = [{**stat, **stat.pop("values")} for stat in page_dirs]
+
         page_dirs = [camel_to_snake_dict(stat) for stat in page_dirs]
         return [cls(**stat) for stat in page_dirs]
+
+    @classmethod
+    def _parse_response(cls, response):
+        """Parse API response into list of stat dictionaries.
+
+        Override this method in subclasses for custom response parsing.
+        Default implementation handles standard stats API format.
+        """
+        if not isinstance(response, list) or not response:
+            return []
+        page_dirs = [d for d in response if isinstance(d, dict)]
+        if page_dirs and "values" in page_dirs[0]:
+            page_dirs = [{**stat, **stat.pop("values")} for stat in page_dirs]
+        return page_dirs
diff --git a/src/garth/stats/training_status/daily.py b/src/garth/stats/training_status/daily.py
@@ -1,11 +1,7 @@
-from datetime import date
 from typing import ClassVar
 
 from pydantic.dataclasses import dataclass
-from typing_extensions import Self
 
-from ... import http
-from ...utils import camel_to_snake_dict, format_end_date
 from .._base import Stats
 
 
@@ -41,33 +37,11 @@ class DailyTrainingStatus(Stats):
     _page_size: ClassVar[int] = 28
 
     @classmethod
-    def list(
-        cls,
-        end: date | str | None = None,
-        period: int = 1,
-        *,
-        client: http.Client | None = None,
-    ) -> list[Self]:
-        client = client or http.client
-        end = format_end_date(end)
-
-        path = cls._path.format(end=end)
-        response = client.connectapi(path)
+    def _parse_response(cls, response):
+        """Extract training data from the daily API response structure."""
         if not isinstance(response, dict):
             return []
 
-        # Extract training data from the nested response structure
-        training_data = cls._extract_daily_training_data(response)
-        if not training_data:
-            return []
-
-        # Convert to snake_case and create instances
-        converted_data = [camel_to_snake_dict(item) for item in training_data]
-        return [cls(**item) for item in converted_data]
-
-    @classmethod
-    def _extract_daily_training_data(cls, response: dict):
-        """Extract training data from the daily API response structure."""
         data_section = response.get("mostRecentTrainingStatus", {})
         if not isinstance(data_section, dict):
             return []
diff --git a/src/garth/stats/training_status/monthly.py b/src/garth/stats/training_status/monthly.py
@@ -1,11 +1,7 @@
-from datetime import date, timedelta
 from typing import ClassVar
 
 from pydantic.dataclasses import dataclass
-from typing_extensions import Self
 
-from ... import http
-from ...utils import camel_to_snake_dict, format_end_date
 from .._base import Stats
 
 
@@ -41,46 +37,11 @@ class MonthlyTrainingStatus(Stats):
     _page_size: ClassVar[int] = 12
 
     @classmethod
-    def list(
-        cls,
-        end: date | str | None = None,
-        period: int = 1,
-        *,
-        client: http.Client | None = None,
-    ) -> list[Self]:
-        client = client or http.client
-        end = format_end_date(end)
-        period_type = "weeks"
-
-        if period > cls._page_size:
-            page = cls.list(end, cls._page_size, client=client)
-            if not page:
-                return []
-            remaining_page = cls.list(
-                end - timedelta(**{period_type: cls._page_size}),
-                period - cls._page_size,
-                client=client,
-            )
-            return remaining_page + page
-
-        start = end - timedelta(**{period_type: period - 1})
-        path = cls._path.format(start=start, end=end)
-        response = client.connectapi(path)
+    def _parse_response(cls, response):
+        """Extract training data from the monthly API response structure."""
         if not isinstance(response, dict):
             return []
 
-        # Extract training data from the nested response structure
-        training_data = cls._extract_monthly_training_data(response)
-        if not training_data:
-            return []
-
-        # Convert to snake_case and create instances
-        converted_data = [camel_to_snake_dict(item) for item in training_data]
-        return [cls(**item) for item in converted_data]
-
-    @classmethod
-    def _extract_monthly_training_data(cls, response: dict):
-        """Extract training data from the monthly API response structure."""
         data_section = response.get("monthlyTrainingStatus", {})
         if not isinstance(data_section, dict):
             return []
diff --git a/src/garth/stats/training_status/weekly.py b/src/garth/stats/training_status/weekly.py
@@ -1,11 +1,7 @@
-from datetime import date, timedelta
 from typing import ClassVar
 
 from pydantic.dataclasses import dataclass
-from typing_extensions import Self
 
-from ... import http
-from ...utils import camel_to_snake_dict, format_end_date
 from .._base import Stats
 
 
@@ -41,46 +37,11 @@ class WeeklyTrainingStatus(Stats):
     _page_size: ClassVar[int] = 52
 
     @classmethod
-    def list(
-        cls,
-        end: date | str | None = None,
-        period: int = 1,
-        *,
-        client: http.Client | None = None,
-    ) -> list[Self]:
-        client = client or http.client
-        end = format_end_date(end)
-        period_type = "weeks"
-
-        if period > cls._page_size:
-            page = cls.list(end, cls._page_size, client=client)
-            if not page:
-                return []
-            remaining_page = cls.list(
-                end - timedelta(**{period_type: cls._page_size}),
-                period - cls._page_size,
-                client=client,
-            )
-            return remaining_page + page
-
-        start = end - timedelta(**{period_type: period - 1})
-        path = cls._path.format(start=start, end=end)
-        response = client.connectapi(path)
+    def _parse_response(cls, response):
+        """Extract training data from the weekly API response structure."""
         if not isinstance(response, dict):
             return []
 
-        # Extract training data from the nested response structure
-        training_data = cls._extract_weekly_training_data(response)
-        if not training_data:
-            return []
-
-        # Convert to snake_case and create instances
-        converted_data = [camel_to_snake_dict(item) for item in training_data]
-        return [cls(**item) for item in converted_data]
-
-    @classmethod
-    def _extract_weekly_training_data(cls, response: dict):
-        """Extract training data from the weekly API response structure."""
         data_section = response.get("weeklyTrainingStatus", {})
         if not isinstance(data_section, dict):
             return []
diff --git a/tests/stats/test_training_status.py b/tests/stats/test_training_status.py
@@ -66,28 +66,28 @@ def test_monthly_training_status_no_data(authed_client: Client):
 
 
 def test_training_status_extract_data_error_cases():
-    """Test error handling in _extract_training_data methods."""
+    """Test error handling in _parse_response methods."""
     from garth.stats.training_status import (
         DailyTrainingStatus,
         MonthlyTrainingStatus,
         WeeklyTrainingStatus,
     )
 
     # Test daily endpoint error cases
-    result = DailyTrainingStatus._extract_daily_training_data({})
+    result = DailyTrainingStatus._parse_response({})
     assert result == []
 
-    result = DailyTrainingStatus._extract_daily_training_data(
+    result = DailyTrainingStatus._parse_response(
         {"mostRecentTrainingStatus": "not a dict"}
     )
     assert result == []
 
-    result = DailyTrainingStatus._extract_daily_training_data(
+    result = DailyTrainingStatus._parse_response(
         {"mostRecentTrainingStatus": {"payload": "not a dict"}}
     )
     assert result == []
 
-    result = DailyTrainingStatus._extract_daily_training_data(
+    result = DailyTrainingStatus._parse_response(
         {
             "mostRecentTrainingStatus": {
                 "payload": {"latestTrainingStatusData": "not a dict"}
@@ -97,39 +97,39 @@ def test_training_status_extract_data_error_cases():
     assert result == []
 
     # Test weekly endpoint error cases
-    result = WeeklyTrainingStatus._extract_weekly_training_data({})
+    result = WeeklyTrainingStatus._parse_response({})
     assert result == []
 
-    result = WeeklyTrainingStatus._extract_weekly_training_data(
+    result = WeeklyTrainingStatus._parse_response(
         {"weeklyTrainingStatus": "not a dict"}
     )
     assert result == []
 
-    result = WeeklyTrainingStatus._extract_weekly_training_data(
+    result = WeeklyTrainingStatus._parse_response(
         {"weeklyTrainingStatus": {"payload": "not a dict"}}
     )
     assert result == []
 
-    result = WeeklyTrainingStatus._extract_weekly_training_data(
+    result = WeeklyTrainingStatus._parse_response(
         {"weeklyTrainingStatus": {"payload": {"reportData": "not a dict"}}}
     )
     assert result == []
 
     # Test monthly endpoint error cases
-    result = MonthlyTrainingStatus._extract_monthly_training_data({})
+    result = MonthlyTrainingStatus._parse_response({})
     assert result == []
 
-    result = MonthlyTrainingStatus._extract_monthly_training_data(
+    result = MonthlyTrainingStatus._parse_response(
         {"monthlyTrainingStatus": "not a dict"}
     )
     assert result == []
 
-    result = MonthlyTrainingStatus._extract_monthly_training_data(
+    result = MonthlyTrainingStatus._parse_response(
         {"monthlyTrainingStatus": {"payload": "not a dict"}}
     )
     assert result == []
 
-    result = MonthlyTrainingStatus._extract_monthly_training_data(
+    result = MonthlyTrainingStatus._parse_response(
         {"monthlyTrainingStatus": {"payload": {"reportData": "not a dict"}}}
     )
     assert result == []
