Remove segment leaderboard

strava_mcp/api.py

@@ -9,7 +9,6 @@ from strava_mcp.models import (
     Activity,
     DetailedActivity,
     ErrorResponse,
-    Leaderboard,
     SegmentEffort,
 )
 
@@ -202,62 +201,3 @@ class StravaAPI:
 
         return segment_efforts
 
-    async def get_segment_leaderboard(
-        self,
-        segment_id: int,
-        gender: str | None = None,
-        age_group: int | None = None,
-        weight_class: int | None = None,
-        following: bool | None = None,
-        club_id: int | None = None,
-        date_range: int | None = None,
-        context_entries: int | None = None,
-        page: int = 1,
-        per_page: int = 30,
-    ) -> Leaderboard:
-        """Get the leaderboard for a given segment.
-
-        Args:
-            segment_id: The ID of the segment
-            gender: Filter by gender ('M' or 'F')
-            age_group: Filter by age group
-            weight_class: Filter by weight class
-            following: Filter by friends of the authenticated athlete
-            club_id: Filter by club
-            date_range: Filter by date range
-            context_entries: Number of context entries
-            page: Page number
-            per_page: Number of items per page
-
-        Returns:
-            The segment leaderboard
-        """
-        params = {"page": page, "per_page": per_page}
-
-        if gender:
-            # Convert gender string to integer code
-            gender_code = 0  # Default
-            if gender.upper() == "M":
-                gender_code = 1
-            elif gender.upper() == "F":
-                gender_code = 2
-            params["gender"] = gender_code
-        if age_group:
-            params["age_group"] = int(age_group)
-        if weight_class:
-            params["weight_class"] = int(weight_class)
-        if following is not None:
-            params["following"] = 1 if following else 0
-        if club_id:
-            params["club_id"] = club_id
-        if date_range:
-            params["date_range"] = int(date_range)
-        if context_entries:
-            params["context_entries"] = context_entries
-
-        response = await self._request(
-            "GET", f"/segments/{segment_id}/leaderboard", params=params
-        )
-        data = response.json()
-
-        return Leaderboard(**data)

strava_mcp/models.py

@@ -137,44 +137,6 @@ class SegmentEffort(BaseModel):
     segment: Segment = Field(..., description="The segment")
 
 
-class Leaderboard(BaseModel):
-    """Represents a Strava segment leaderboard."""
-
-    entry_count: int = Field(
-        ..., description="The total number of entries for this leaderboard"
-    )
-    effort_count: int = Field(
-        ..., description="The total number of efforts for this leaderboard"
-    )
-    kom_type: str | None = Field(None, description="KOM/QOM type")
-    entries: list[dict] = Field(..., description="List of leaderboard entries")
-
-
-class LeaderboardEntry(BaseModel):
-    """Represents a Strava segment leaderboard entry."""
-
-    athlete_name: str = Field(..., description="The name of the athlete")
-    athlete_id: int = Field(..., description="The unique identifier of the athlete")
-    athlete_gender: str = Field(..., description="The gender of the athlete")
-    average_hr: float | None = Field(
-        None, description="The athlete's average heart rate"
-    )
-    average_watts: float | None = Field(None, description="The athlete's average watts")
-    distance: float = Field(..., description="The distance in meters")
-    elapsed_time: int = Field(..., description="The elapsed time in seconds")
-    moving_time: int = Field(..., description="The moving time in seconds")
-    start_date: datetime = Field(..., description="The timestamp of the effort in UTC")
-    start_date_local: datetime = Field(
-        ..., description="The timestamp of the effort in local time"
-    )
-    activity_id: int = Field(..., description="The unique identifier of the activity")
-    effort_id: int = Field(
-        ..., description="The unique identifier of the segment effort"
-    )
-    rank: int = Field(
-        ..., description="The rank of the effort on the segment leaderboard"
-    )
-    neighborhood_index: int | None = Field(None, description="Neighborhood index")
 
 
 class ErrorResponse(BaseModel):

strava_mcp/server.py

@@ -134,54 +134,3 @@ async def get_activity_segments(
         raise
 
 
-@mcp.tool()
-async def get_segment_leaderboard(
-    ctx: Context,
-    segment_id: int,
-    gender: str | None = None,
-    age_group: str | None = None,
-    weight_class: str | None = None,
-    following: bool | None = None,
-    club_id: int | None = None,
-    date_range: str | None = None,
-    context_entries: int | None = None,
-    page: int = 1,
-    per_page: int = 30,
-) -> dict:
-    """Get the leaderboard for a given segment.
-
-    Args:
-        ctx: The MCP request context
-        segment_id: The ID of the segment
-        gender: Filter by gender ('M' or 'F')
-        age_group: Filter by age group
-        weight_class: Filter by weight class
-        following: Filter by friends of the authenticated athlete
-        club_id: Filter by club
-        date_range: Filter by date range
-        context_entries: Number of context entries
-        page: Page number
-        per_page: Number of items per page
-
-    Returns:
-        The segment leaderboard
-    """
-    service = ctx.request_context.lifespan_context["service"]
-
-    try:
-        leaderboard = await service.get_segment_leaderboard(
-            segment_id,
-            gender,
-            age_group,
-            weight_class,
-            following,
-            club_id,
-            date_range,
-            context_entries,
-            page,
-            per_page,
-        )
-        return leaderboard.model_dump()
-    except Exception as e:
-        logger.error(f"Error in get_segment_leaderboard tool: {str(e)}")
-        raise

strava_mcp/service.py

@@ -2,7 +2,7 @@ import logging
 
 from strava_mcp.api import StravaAPI
 from strava_mcp.config import StravaSettings
-from strava_mcp.models import Activity, DetailedActivity, Leaderboard, SegmentEffort
+from strava_mcp.models import Activity, DetailedActivity, SegmentEffort
 
 logger = logging.getLogger(__name__)
 
@@ -89,54 +89,3 @@ class StravaService:
             logger.error(f"Error getting segments for activity {activity_id}: {str(e)}")
             raise
 
-    async def get_segment_leaderboard(
-        self,
-        segment_id: int,
-        gender: str | None = None,
-        age_group: int | None = None,
-        weight_class: int | None = None,
-        following: bool | None = None,
-        club_id: int | None = None,
-        date_range: int | None = None,
-        context_entries: int | None = None,
-        page: int = 1,
-        per_page: int = 30,
-    ) -> Leaderboard:
-        """Get the leaderboard for a given segment.
-
-        Args:
-            segment_id: The ID of the segment
-            gender: Filter by gender ('M' or 'F')
-            age_group: Filter by age group
-            weight_class: Filter by weight class
-            following: Filter by friends of the authenticated athlete
-            club_id: Filter by club
-            date_range: Filter by date range
-            context_entries: Number of context entries
-            page: Page number
-            per_page: Number of items per page
-
-        Returns:
-            The segment leaderboard
-        """
-        try:
-            logger.info(f"Getting leaderboard for segment {segment_id}")
-            leaderboard = await self.api.get_segment_leaderboard(
-                segment_id,
-                gender,
-                age_group,
-                weight_class,
-                following,
-                club_id,
-                date_range,
-                context_entries,
-                page,
-                per_page,
-            )
-            logger.info(f"Retrieved leaderboard with {leaderboard.entry_count} entries")
-            return leaderboard
-        except Exception as e:
-            logger.error(
-                f"Error getting leaderboard for segment {segment_id}: {str(e)}"
-            )
-            raise

tests/test_api.py

@@ -5,7 +5,7 @@ import pytest
 
 from strava_mcp.api import StravaAPI
 from strava_mcp.config import StravaSettings
-from strava_mcp.models import Activity, DetailedActivity, Leaderboard
+from strava_mcp.models import Activity, DetailedActivity
 
 
 @pytest.fixture
@@ -177,47 +177,3 @@ async def test_get_activity(api, mock_response):
     assert activity.description == activity_data["description"]
 
 
-@pytest.mark.asyncio
-async def test_get_segment_leaderboard(api, mock_response):
-    # Setup mock response
-    leaderboard_data = {
-        "entry_count": 100,
-        "effort_count": 200,
-        "kom_type": "kom",
-        "entries": [
-            {
-                "athlete_name": "John Doe",
-                "athlete_id": 123,
-                "athlete_gender": "M",
-                "average_hr": 160,
-                "average_watts": 250,
-                "distance": 1000,
-                "elapsed_time": 180,
-                "moving_time": 180,
-                "start_date": "2023-01-01T10:00:00Z",
-                "start_date_local": "2023-01-01T10:00:00Z",
-                "activity_id": 12345,
-                "effort_id": 67890,
-                "rank": 1,
-            }
-        ],
-    }
-    mock_response.json.return_value = leaderboard_data
-    api._client.request.return_value = mock_response
-
-    # Test get_segment_leaderboard
-    leaderboard = await api.get_segment_leaderboard(12345)
-
-    # Verify request
-    api._client.request.assert_called_once()
-    args, kwargs = api._client.request.call_args
-    assert args[0] == "GET"
-    assert args[1] == "/segments/12345/leaderboard"
-    assert kwargs["params"] == {"page": 1, "per_page": 30}
-
-    # Verify response
-    assert isinstance(leaderboard, Leaderboard)
-    assert leaderboard.entry_count == leaderboard_data["entry_count"]
-    assert leaderboard.effort_count == leaderboard_data["effort_count"]
-    assert leaderboard.kom_type == leaderboard_data["kom_type"]
-    assert len(leaderboard.entries) == 1

tests/test_server.py

@@ -2,7 +2,7 @@ from unittest.mock import AsyncMock, MagicMock
 
 import pytest
 
-from strava_mcp.models import Activity, DetailedActivity, Leaderboard, SegmentEffort
+from strava_mcp.models import Activity, DetailedActivity, SegmentEffort
 
 
 class MockContext:
@@ -19,7 +19,6 @@ def mock_service():
     mock.get_activities = AsyncMock()
     mock.get_activity = AsyncMock()
     mock.get_activity_segments = AsyncMock()
-    mock.get_segment_leaderboard = AsyncMock()
     return mock
 
 
@@ -171,45 +170,3 @@ async def test_get_activity_segments(mock_ctx, mock_service):
     assert result[0]["name"] == mock_segment.name
 
 
-@pytest.mark.asyncio
-async def test_get_segment_leaderboard(mock_ctx, mock_service):
-    # Setup mock data
-    mock_leaderboard = Leaderboard(
-        entry_count=100,
-        effort_count=200,
-        kom_type="kom",
-        entries=[
-            {
-                "athlete_name": "John Doe",
-                "athlete_id": 123,
-                "athlete_gender": "M",
-                "average_hr": 160,
-                "average_watts": 250,
-                "distance": 1000,
-                "elapsed_time": 180,
-                "moving_time": 180,
-                "start_date": "2023-01-01T10:00:00Z",
-                "start_date_local": "2023-01-01T10:00:00Z",
-                "activity_id": 12345,
-                "effort_id": 67890,
-                "rank": 1,
-            }
-        ],
-    )
-    mock_service.get_segment_leaderboard.return_value = mock_leaderboard
-
-    # Test tool
-    from strava_mcp.server import get_segment_leaderboard
-
-    result = await get_segment_leaderboard(mock_ctx, 12345)
-
-    # Verify service call
-    mock_service.get_segment_leaderboard.assert_called_once_with(
-        12345, None, None, None, None, None, None, None, 1, 30
-    )
-
-    # Verify result
-    assert result["entry_count"] == mock_leaderboard.entry_count
-    assert result["effort_count"] == mock_leaderboard.effort_count
-    assert result["kom_type"] == mock_leaderboard.kom_type
-    assert len(result["entries"]) == 1

tests/test_service.py

@@ -3,7 +3,7 @@ from unittest.mock import AsyncMock, patch
 import pytest
 
 from strava_mcp.config import StravaSettings
-from strava_mcp.models import Activity, DetailedActivity, Leaderboard, SegmentEffort
+from strava_mcp.models import Activity, DetailedActivity, SegmentEffort
 from strava_mcp.service import StravaService
 
 
@@ -22,7 +22,6 @@ def mock_api():
     mock.get_activities = AsyncMock()
     mock.get_activity = AsyncMock()
     mock.get_activity_segments = AsyncMock()
-    mock.get_segment_leaderboard = AsyncMock()
     return mock
 
 
@@ -166,40 +165,3 @@ async def test_get_activity_segments(service, mock_api):
     assert segments[0] == mock_segment
 
 
-@pytest.mark.asyncio
-async def test_get_segment_leaderboard(service, mock_api):
-    # Setup mocked data
-    mock_leaderboard = Leaderboard(
-        entry_count=100,
-        effort_count=200,
-        kom_type="kom",
-        entries=[
-            {
-                "athlete_name": "John Doe",
-                "athlete_id": 123,
-                "athlete_gender": "M",
-                "average_hr": 160,
-                "average_watts": 250,
-                "distance": 1000,
-                "elapsed_time": 180,
-                "moving_time": 180,
-                "start_date": "2023-01-01T10:00:00Z",
-                "start_date_local": "2023-01-01T10:00:00Z",
-                "activity_id": 12345,
-                "effort_id": 67890,
-                "rank": 1,
-            }
-        ],
-    )
-    mock_api.get_segment_leaderboard.return_value = mock_leaderboard
-
-    # Test get_segment_leaderboard
-    leaderboard = await service.get_segment_leaderboard(12345)
-
-    # Verify API call
-    mock_api.get_segment_leaderboard.assert_called_once_with(
-        12345, None, None, None, None, None, None, None, 1, 30
-    )
-
-    # Verify response
-    assert leaderboard == mock_leaderboard