First implementation

README.md

@@ -0,0 +1,144 @@
+# Strava MCP Server
+
+A Model Context Protocol (MCP) server for interacting with the Strava API.
+
+## Features
+
+This MCP server provides tools to access data from the Strava API:
+
+- Get user's activities
+- Get a specific activity's details
+- Get the segments of an activity
+- Get the leaderboard of a segment
+
+## Installation
+
+### Prerequisites
+
+- Python 3.13 or later
+- Strava API credentials (client ID, client secret, and refresh token)
+
+### Setup
+
+1. Clone the repository:
+
+```bash
+git clone <repository-url>
+cd strava
+```
+
+2. Install dependencies with [uv](https://docs.astral.sh/uv/):
+
+```bash
+uv install
+```
+
+3. Set up environment variables with your Strava API credentials:
+
+```bash
+export STRAVA_CLIENT_ID=your_client_id
+export STRAVA_CLIENT_SECRET=your_client_secret
+export STRAVA_REFRESH_TOKEN=your_refresh_token
+```
+
+Alternatively, you can create a `.env` file in the root directory with these variables.
+
+## Usage
+
+### Running the Server
+
+To run the server:
+
+```bash
+python main.py
+```
+
+### Development Mode
+
+You can run the server in development mode with the MCP CLI:
+
+```bash
+mcp dev main.py
+```
+
+### Installing in Claude Desktop
+
+To install the server in Claude Desktop:
+
+```bash
+mcp install main.py
+```
+
+## Tools
+
+### Get User Activities
+
+Retrieves a list of activities for the authenticated user.
+
+**Parameters:**
+- `before` (optional): Epoch timestamp to filter activities before a certain time
+- `after` (optional): Epoch timestamp to filter activities after a certain time
+- `page` (optional): Page number (default: 1)
+- `per_page` (optional): Number of items per page (default: 30)
+
+### Get Activity
+
+Gets detailed information about a specific activity.
+
+**Parameters:**
+- `activity_id`: The ID of the activity
+- `include_all_efforts` (optional): Whether to include all segment efforts (default: false)
+
+### Get Activity Segments
+
+Retrieves the segments from a specific activity.
+
+**Parameters:**
+- `activity_id`: The ID of the activity
+
+### Get Segment Leaderboard
+
+Gets the leaderboard for a specific segment.
+
+**Parameters:**
+- `segment_id`: The ID of the segment
+- `gender` (optional): Filter by gender ('M' or 'F')
+- `age_group` (optional): Filter by age group
+- `weight_class` (optional): Filter by weight class
+- `following` (optional): Filter by friends of the authenticated athlete
+- `club_id` (optional): Filter by club
+- `date_range` (optional): Filter by date range
+- `context_entries` (optional): Number of context entries
+- `page` (optional): Page number (default: 1)
+- `per_page` (optional): Number of items per page (default: 30)
+
+## Development
+
+### Project Structure
+
+- `strava_mcp/`: Main package directory
+  - `__init__.py`: Package initialization
+  - `config.py`: Configuration settings using pydantic-settings
+  - `models.py`: Pydantic models for Strava API entities
+  - `api.py`: Low-level API client for Strava
+  - `service.py`: Service layer for business logic
+  - `server.py`: MCP server implementation
+- `tests/`: Unit tests
+- `main.py`: Entry point to run the server
+
+### Running Tests
+
+To run tests:
+
+```bash
+pytest
+```
+
+## License
+
+[MIT License](LICENSE)
+
+## Acknowledgements
+
+- [Strava API](https://developers.strava.com/)
+- [Model Context Protocol (MCP)](https://modelcontextprotocol.io/)

main.py

@@ -1,5 +1,9 @@
+from strava_mcp.server import mcp
+
+
 def main():
-    print("Hello from strava!")
+    """Run the Strava MCP server."""
+    mcp.run()
 
 
 if __name__ == "__main__":

pyproject.toml

@@ -17,4 +17,5 @@ dev = [
     "ipykernel>=6.29.5",
     "pytest>=8.3.5",
     "pytest-mock>=3.14.0",
+    "pytest-asyncio>=0.23.5",
 ]

specs/poc.md

@@ -26,6 +26,8 @@ No resources are to be exposed for now.
 
 ## Details
 
+Be VERY CAREFUL to follow the instructions:
+
 1. Read the documentation of the Strava API and MCP in ai-docs directory.
 2. Do not add any dependencies to the project, except for the ones that are already installed (see pyproject.toml).
 3. Add relevant comments to the code to explain what it does.
@@ -36,7 +38,11 @@ No resources are to be exposed for now.
 8. Use pydantic for Model Driven Development.
 9. Use pydantic-settings for configuration.
 10. Separate logic, api, and data access layers.
-
+11. Use type hints and docstrings to describe the code.
+12. Write the tests first, and then implement the code 
+13. Setup CI/CD pipeline with Github Actions, and make unit tests pass, then that server starts. Upload code coverage to Codecov.
+14. Use uv to manage the project.
+15. Setup pre-commit hooks with Ruff, isort, and pyright.
 
 
 

strava_mcp/__init__.py

@@ -0,0 +1 @@
+# Strava MCP package

strava_mcp/api.py

@@ -0,0 +1,233 @@
+import logging
+from typing import Dict, List, Optional, Tuple, Any
+from datetime import datetime
+
+import httpx
+from httpx import Response
+
+from strava_mcp.config import StravaSettings
+from strava_mcp.models import (
+    Activity, 
+    DetailedActivity, 
+    Segment,
+    SegmentEffort,
+    Leaderboard,
+    ErrorResponse,
+)
+
+
+logger = logging.getLogger(__name__)
+
+
+class StravaAPI:
+    """Client for the Strava API."""
+    
+    def __init__(self, settings: StravaSettings):
+        """Initialize the Strava API client.
+        
+        Args:
+            settings: Strava API settings
+        """
+        self.settings = settings
+        self.access_token = None
+        self.token_expires_at = None
+        self._client = httpx.AsyncClient(
+            base_url=settings.base_url,
+            timeout=30.0,
+        )
+    
+    async def close(self):
+        """Close the HTTP client."""
+        await self._client.aclose()
+    
+    async def _ensure_token(self) -> str:
+        """Ensure we have a valid access token.
+        
+        Returns:
+            The access token
+        """
+        now = datetime.now().timestamp()
+        
+        # If token is still valid, return it
+        if self.access_token and self.token_expires_at and now < self.token_expires_at:
+            return self.access_token
+        
+        # Otherwise, refresh the token
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                "https://www.strava.com/oauth/token",
+                json={
+                    "client_id": self.settings.client_id,
+                    "client_secret": self.settings.client_secret,
+                    "refresh_token": self.settings.refresh_token,
+                    "grant_type": "refresh_token",
+                },
+            )
+            
+            if response.status_code != 200:
+                error_msg = f"Failed to refresh token: {response.text}"
+                logger.error(error_msg)
+                raise Exception(error_msg)
+            
+            data = response.json()
+            self.access_token = data["access_token"]
+            self.token_expires_at = data["expires_at"]
+            
+            logger.info("Successfully refreshed access token")
+            return self.access_token
+    
+    async def _request(self, method: str, endpoint: str, **kwargs) -> Response:
+        """Make a request to the Strava API.
+        
+        Args:
+            method: The HTTP method to use
+            endpoint: The API endpoint to call
+            **kwargs: Additional arguments to pass to the HTTP client
+        
+        Returns:
+            The HTTP response
+        
+        Raises:
+            Exception: If the request fails
+        """
+        token = await self._ensure_token()
+        headers = {"Authorization": f"Bearer {token}"}
+        if "headers" in kwargs:
+            headers.update(kwargs.pop("headers"))
+        
+        url = endpoint if endpoint.startswith("/") else f"/{endpoint}"
+        response = await self._client.request(
+            method, 
+            url, 
+            headers=headers, 
+            **kwargs
+        )
+        
+        if not response.is_success:
+            error_msg = f"Strava API request failed: {response.status_code} - {response.text}"
+            logger.error(error_msg)
+            
+            try:
+                error_data = response.json()
+                error = ErrorResponse(**error_data)
+                raise Exception(f"Strava API error: {error.message} (code: {error.code})")
+            except Exception as e:
+                raise Exception(f"Strava API request failed: {response.status_code} - {response.text}")
+        
+        return response
+    
+    async def get_activities(
+        self, 
+        before: Optional[int] = None,
+        after: Optional[int] = None,
+        page: int = 1,
+        per_page: int = 30
+    ) -> List[Activity]:
+        """Get a list of activities for the authenticated athlete.
+        
+        Args:
+            before: An epoch timestamp to use for filtering activities that have taken place before a certain time
+            after: An epoch timestamp to use for filtering activities that have taken place after a certain time
+            page: Page number
+            per_page: Number of items per page
+        
+        Returns:
+            List of activities
+        """
+        params = {"page": page, "per_page": per_page}
+        if before:
+            params["before"] = before
+        if after:
+            params["after"] = after
+        
+        response = await self._request("GET", "/athlete/activities", params=params)
+        data = response.json()
+        
+        return [Activity(**activity) for activity in data]
+    
+    async def get_activity(self, activity_id: int, include_all_efforts: bool = False) -> DetailedActivity:
+        """Get a specific activity.
+        
+        Args:
+            activity_id: The ID of the activity
+            include_all_efforts: Whether to include all segment efforts
+        
+        Returns:
+            The activity details
+        """
+        params = {}
+        if include_all_efforts:
+            params["include_all_efforts"] = "true"
+        
+        response = await self._request("GET", f"/activities/{activity_id}", params=params)
+        data = response.json()
+        
+        return DetailedActivity(**data)
+    
+    async def get_activity_segments(self, activity_id: int) -> List[SegmentEffort]:
+        """Get segments from a specific activity.
+        
+        Args:
+            activity_id: The ID of the activity
+        
+        Returns:
+            List of segment efforts for the activity
+        """
+        activity = await self.get_activity(activity_id, include_all_efforts=True)
+        
+        if not activity.segment_efforts:
+            return []
+        
+        return [SegmentEffort.parse_obj(effort) for effort in activity.segment_efforts]
+    
+    async def get_segment_leaderboard(
+        self, 
+        segment_id: int,
+        gender: Optional[str] = None,
+        age_group: Optional[str] = None,
+        weight_class: Optional[str] = None,
+        following: Optional[bool] = None,
+        club_id: Optional[int] = None,
+        date_range: Optional[str] = None,
+        context_entries: Optional[int] = 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:
+            params["gender"] = gender
+        if age_group:
+            params["age_group"] = age_group
+        if weight_class:
+            params["weight_class"] = weight_class
+        if following is not None:
+            params["following"] = "true" if following else "false"
+        if club_id:
+            params["club_id"] = club_id
+        if date_range:
+            params["date_range"] = 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/config.py

@@ -0,0 +1,12 @@
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from pydantic import Field
+
+
+class StravaSettings(BaseSettings):
+    """Strava API settings."""
+    client_id: str = Field(..., description="Strava API client ID")
+    client_secret: str = Field(..., description="Strava API client secret")
+    refresh_token: str = Field(..., description="Strava API refresh token")
+    base_url: str = Field("https://www.strava.com/api/v3", description="Strava API base URL")
+    
+    model_config = SettingsConfigDict(env_prefix="STRAVA_")

strava_mcp/models.py

@@ -0,0 +1,125 @@
+from datetime import datetime
+from typing import List, Optional
+from pydantic import BaseModel, Field
+
+
+class Activity(BaseModel):
+    """Represents a Strava activity."""
+    id: int = Field(..., description="The unique identifier of the activity")
+    name: str = Field(..., description="The name of the activity")
+    distance: float = Field(..., description="The distance in meters")
+    moving_time: int = Field(..., description="Moving time in seconds")
+    elapsed_time: int = Field(..., description="Elapsed time in seconds")
+    total_elevation_gain: float = Field(..., description="Total elevation gain in meters")
+    type: str = Field(..., description="Type of activity")
+    sport_type: str = Field(..., description="Type of sport")
+    start_date: datetime = Field(..., description="Start date and time in UTC")
+    start_date_local: datetime = Field(..., description="Start date and time in athlete's timezone")
+    timezone: str = Field(..., description="The timezone of the activity")
+    achievement_count: int = Field(..., description="The number of achievements")
+    kudos_count: int = Field(..., description="The number of kudos")
+    comment_count: int = Field(..., description="The number of comments")
+    athlete_count: int = Field(..., description="The number of athletes")
+    photo_count: int = Field(..., description="The number of photos")
+    map: Optional[dict] = Field(None, description="The map of the activity")
+    trainer: bool = Field(..., description="Whether this activity was recorded on a training machine")
+    commute: bool = Field(..., description="Whether this activity is a commute")
+    manual: bool = Field(..., description="Whether this activity was created manually")
+    private: bool = Field(..., description="Whether this activity is private")
+    flagged: bool = Field(..., description="Whether this activity is flagged")
+    workout_type: Optional[int] = Field(None, description="The workout type")
+    average_speed: float = Field(..., description="Average speed in meters per second")
+    max_speed: float = Field(..., description="Maximum speed in meters per second")
+    has_heartrate: bool = Field(..., description="Whether the activity has heartrate data")
+    average_heartrate: Optional[float] = Field(None, description="Average heartrate during activity")
+    max_heartrate: Optional[float] = Field(None, description="Maximum heartrate during activity")
+    elev_high: Optional[float] = Field(None, description="The highest elevation")
+    elev_low: Optional[float] = Field(None, description="The lowest elevation")
+
+
+class DetailedActivity(Activity):
+    """Detailed version of a Strava activity."""
+    description: Optional[str] = Field(None, description="The description of the activity")
+    athlete: dict = Field(..., description="The athlete who performed the activity")
+    calories: Optional[float] = Field(None, description="Calories burned during activity")
+    segment_efforts: Optional[List[dict]] = Field(None, description="List of segment efforts")
+    splits_metric: Optional[List[dict]] = Field(None, description="Splits in metric units")
+    splits_standard: Optional[List[dict]] = Field(None, description="Splits in standard units")
+    best_efforts: Optional[List[dict]] = Field(None, description="List of best efforts")
+    photos: Optional[dict] = Field(None, description="Photos associated with activity")
+    gear: Optional[dict] = Field(None, description="Gear used during activity")
+    device_name: Optional[str] = Field(None, description="Name of device used to record activity")
+
+
+class Segment(BaseModel):
+    """Represents a Strava segment."""
+    id: int = Field(..., description="The unique identifier of the segment")
+    name: str = Field(..., description="The name of the segment")
+    activity_type: str = Field(..., description="The activity type of the segment")
+    distance: float = Field(..., description="The segment's distance in meters")
+    average_grade: float = Field(..., description="The segment's average grade, in percents")
+    maximum_grade: float = Field(..., description="The segments's maximum grade, in percents")
+    elevation_high: float = Field(..., description="The segments's highest elevation, in meters")
+    elevation_low: float = Field(..., description="The segments's lowest elevation, in meters")
+    total_elevation_gain: float = Field(..., description="The segments's total elevation gain, in meters")
+    start_latlng: List[float] = Field(..., description="Start coordinates [latitude, longitude]")
+    end_latlng: List[float] = Field(..., description="End coordinates [latitude, longitude]")
+    climb_category: int = Field(..., description="The category of the climb [0, 5]")
+    city: Optional[str] = Field(None, description="The city this segment is in")
+    state: Optional[str] = Field(None, description="The state this segment is in")
+    country: Optional[str] = Field(None, description="The country this segment is in")
+    private: bool = Field(..., description="Whether this segment is private")
+    starred: bool = Field(..., description="Whether this segment is starred by the authenticated athlete")
+
+
+class SegmentEffort(BaseModel):
+    """Represents a Strava segment effort."""
+    id: int = Field(..., description="The unique identifier of the segment effort")
+    activity_id: int = Field(..., description="The ID of the associated activity")
+    segment_id: int = Field(..., description="The ID of the associated segment")
+    name: str = Field(..., description="The name of the segment")
+    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="Start date and time in UTC")
+    start_date_local: datetime = Field(..., description="Start date and time in athlete's timezone")
+    distance: float = Field(..., description="The effort's distance in meters")
+    average_watts: Optional[float] = Field(None, description="Average wattage")
+    device_watts: Optional[bool] = Field(None, description="Whether power data comes from a power meter")
+    average_heartrate: Optional[float] = Field(None, description="Average heartrate")
+    max_heartrate: Optional[float] = Field(None, description="Maximum heartrate")
+    pr_rank: Optional[int] = Field(None, description="Personal record rank (1-3), 0 if not a PR")
+    achievements: Optional[List[dict]] = Field(None, description="List of achievements")
+    athlete: dict = Field(..., description="The athlete who performed the effort")
+    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: Optional[str] = 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: Optional[float] = Field(None, description="The athlete's average heart rate")
+    average_watts: Optional[float] = 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: Optional[int] = Field(None, description="Neighborhood index")
+
+
+class ErrorResponse(BaseModel):
+    """Represents an error response from the Strava API."""
+    message: str = Field(..., description="Error message")
+    code: int = Field(..., description="Error code")

strava_mcp/server.py

@@ -0,0 +1,190 @@
+import logging
+import json
+from typing import List, Optional, Dict, Any
+from contextlib import asynccontextmanager
+from collections.abc import AsyncIterator
+
+from mcp.server.fastmcp import FastMCP, Context
+
+from strava_mcp.config import StravaSettings
+from strava_mcp.service import StravaService
+from strava_mcp.models import Activity, DetailedActivity, SegmentEffort, Leaderboard
+
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+
+@asynccontextmanager
+async def lifespan(server: FastMCP) -> AsyncIterator[Dict[str, Any]]:
+    """Set up and tear down the Strava service for the MCP server.
+    
+    Args:
+        server: The FastMCP server instance
+    
+    Yields:
+        The lifespan context containing the Strava service
+    """
+    # Load settings from environment variables
+    try:
+        settings = StravaSettings()
+        logger.info("Loaded Strava API settings")
+    except Exception as e:
+        logger.error(f"Failed to load Strava API settings: {str(e)}")
+        raise
+    
+    # Initialize the Strava service
+    service = StravaService(settings)
+    logger.info("Initialized Strava service")
+    
+    try:
+        yield {"service": service}
+    finally:
+        # Clean up resources
+        await service.close()
+        logger.info("Closed Strava service")
+
+
+# Create the MCP server
+mcp = FastMCP(
+    "Strava",
+    description="MCP server for interacting with the Strava API",
+    lifespan=lifespan,
+)
+
+
+@mcp.tool()
+async def get_user_activities(
+    ctx: Context,
+    before: Optional[int] = None,
+    after: Optional[int] = None,
+    page: int = 1,
+    per_page: int = 30,
+) -> List[Dict]:
+    """Get the authenticated user's activities.
+    
+    Args:
+        ctx: The MCP request context
+        before: An epoch timestamp to use for filtering activities that have taken place before a certain time
+        after: An epoch timestamp to use for filtering activities that have taken place after a certain time
+        page: Page number
+        per_page: Number of items per page
+    
+    Returns:
+        List of activities
+    """
+    service = ctx.request_context.lifespan_context["service"]
+    
+    try:
+        activities = await service.get_activities(before, after, page, per_page)
+        return [activity.model_dump() for activity in activities]
+    except Exception as e:
+        logger.error(f"Error in get_user_activities tool: {str(e)}")
+        raise
+
+
+@mcp.tool()
+async def get_activity(
+    ctx: Context,
+    activity_id: int,
+    include_all_efforts: bool = False,
+) -> Dict:
+    """Get details of a specific activity.
+    
+    Args:
+        ctx: The MCP request context
+        activity_id: The ID of the activity
+        include_all_efforts: Whether to include all segment efforts
+    
+    Returns:
+        The activity details
+    """
+    service = ctx.request_context.lifespan_context["service"]
+    
+    try:
+        activity = await service.get_activity(activity_id, include_all_efforts)
+        return activity.model_dump()
+    except Exception as e:
+        logger.error(f"Error in get_activity tool: {str(e)}")
+        raise
+
+
+@mcp.tool()
+async def get_activity_segments(
+    ctx: Context,
+    activity_id: int,
+) -> List[Dict]:
+    """Get the segments of a specific activity.
+    
+    Args:
+        ctx: The MCP request context
+        activity_id: The ID of the activity
+    
+    Returns:
+        List of segment efforts for the activity
+    """
+    service = ctx.request_context.lifespan_context["service"]
+    
+    try:
+        segments = await service.get_activity_segments(activity_id)
+        return [segment.model_dump() for segment in segments]
+    except Exception as e:
+        logger.error(f"Error in get_activity_segments tool: {str(e)}")
+        raise
+
+
+@mcp.tool()
+async def get_segment_leaderboard(
+    ctx: Context,
+    segment_id: int,
+    gender: Optional[str] = None,
+    age_group: Optional[str] = None,
+    weight_class: Optional[str] = None,
+    following: Optional[bool] = None,
+    club_id: Optional[int] = None,
+    date_range: Optional[str] = None,
+    context_entries: Optional[int] = 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

@@ -0,0 +1,140 @@
+import logging
+from typing import List, Optional, Any, Dict
+
+from strava_mcp.config import StravaSettings
+from strava_mcp.api import StravaAPI
+from strava_mcp.models import Activity, DetailedActivity, SegmentEffort, Leaderboard
+
+
+logger = logging.getLogger(__name__)
+
+
+class StravaService:
+    """Service for interacting with the Strava API."""
+    
+    def __init__(self, settings: StravaSettings):
+        """Initialize the Strava service.
+        
+        Args:
+            settings: Strava API settings
+        """
+        self.settings = settings
+        self.api = StravaAPI(settings)
+    
+    async def close(self):
+        """Close the API client."""
+        await self.api.close()
+    
+    async def get_activities(
+        self,
+        before: Optional[int] = None,
+        after: Optional[int] = None,
+        page: int = 1,
+        per_page: int = 30
+    ) -> List[Activity]:
+        """Get a list of activities for the authenticated athlete.
+        
+        Args:
+            before: An epoch timestamp to use for filtering activities that have taken place before a certain time
+            after: An epoch timestamp to use for filtering activities that have taken place after a certain time
+            page: Page number
+            per_page: Number of items per page
+            
+        Returns:
+            List of activities
+        """
+        try:
+            logger.info("Getting activities for authenticated athlete")
+            activities = await self.api.get_activities(before, after, page, per_page)
+            logger.info(f"Retrieved {len(activities)} activities")
+            return activities
+        except Exception as e:
+            logger.error(f"Error getting activities: {str(e)}")
+            raise
+    
+    async def get_activity(self, activity_id: int, include_all_efforts: bool = False) -> DetailedActivity:
+        """Get a specific activity.
+        
+        Args:
+            activity_id: The ID of the activity
+            include_all_efforts: Whether to include all segment efforts
+            
+        Returns:
+            The activity details
+        """
+        try:
+            logger.info(f"Getting activity {activity_id}")
+            activity = await self.api.get_activity(activity_id, include_all_efforts)
+            logger.info(f"Retrieved activity: {activity.name}")
+            return activity
+        except Exception as e:
+            logger.error(f"Error getting activity {activity_id}: {str(e)}")
+            raise
+    
+    async def get_activity_segments(self, activity_id: int) -> List[SegmentEffort]:
+        """Get segments from a specific activity.
+        
+        Args:
+            activity_id: The ID of the activity
+            
+        Returns:
+            List of segment efforts for the activity
+        """
+        try:
+            logger.info(f"Getting segments for activity {activity_id}")
+            segments = await self.api.get_activity_segments(activity_id)
+            logger.info(f"Retrieved {len(segments)} segments")
+            return segments
+        except Exception as e:
+            logger.error(f"Error getting segments for activity {activity_id}: {str(e)}")
+            raise
+    
+    async def get_segment_leaderboard(
+        self,
+        segment_id: int,
+        gender: Optional[str] = None,
+        age_group: Optional[str] = None,
+        weight_class: Optional[str] = None,
+        following: Optional[bool] = None,
+        club_id: Optional[int] = None,
+        date_range: Optional[str] = None,
+        context_entries: Optional[int] = 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/__init__.py

@@ -0,0 +1 @@
+# Test package for the Strava MCP server

tests/test_api.py

@@ -0,0 +1,222 @@
+import pytest
+from datetime import datetime
+from unittest.mock import AsyncMock, MagicMock, patch
+
+from strava_mcp.config import StravaSettings
+from strava_mcp.api import StravaAPI
+from strava_mcp.models import Activity, DetailedActivity, Leaderboard
+
+
+@pytest.fixture
+def settings():
+    return StravaSettings(
+        client_id="test_client_id",
+        client_secret="test_client_secret",
+        refresh_token="test_refresh_token",
+    )
+
+
+@pytest.fixture
+def mock_response():
+    mock = MagicMock()
+    mock.is_success = True
+    mock.json = MagicMock(return_value={})
+    mock.status_code = 200
+    return mock
+
+
+@pytest.fixture
+def api(settings):
+    api = StravaAPI(settings)
+    api._client = AsyncMock()
+    api.access_token = "test_access_token"
+    api.token_expires_at = datetime.now().timestamp() + 3600
+    return api
+
+
+@pytest.mark.asyncio
+async def test_ensure_token_valid(api):
+    # Token is already valid
+    token = await api._ensure_token()
+    assert token == "test_access_token"
+    
+
+@pytest.mark.asyncio
+async def test_ensure_token_refresh(settings):
+    with patch("httpx.AsyncClient") as mock_client:
+        # Setup mock for token refresh
+        mock_instance = mock_client.return_value.__aenter__.return_value
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "access_token": "new_access_token",
+            "expires_at": datetime.now().timestamp() + 3600,
+        }
+        mock_instance.post.return_value = mock_response
+        
+        # Create API with expired token
+        api = StravaAPI(settings)
+        api.access_token = "old_access_token"
+        api.token_expires_at = datetime.now().timestamp() - 3600
+        
+        # Test token refresh
+        token = await api._ensure_token()
+        assert token == "new_access_token"
+        
+        # Verify correct API call was made
+        mock_instance.post.assert_called_once()
+        args, kwargs = mock_instance.post.call_args
+        assert args[0] == "https://www.strava.com/oauth/token"
+        assert kwargs["json"]["client_id"] == "test_client_id"
+        assert kwargs["json"]["client_secret"] == "test_client_secret"
+        assert kwargs["json"]["refresh_token"] == "test_refresh_token"
+        assert kwargs["json"]["grant_type"] == "refresh_token"
+
+
+@pytest.mark.asyncio
+async def test_get_activities(api, mock_response):
+    # Setup mock response
+    activity_data = {
+        "id": 1234567890,
+        "name": "Morning Run",
+        "distance": 5000,
+        "moving_time": 1200,
+        "elapsed_time": 1300,
+        "total_elevation_gain": 50,
+        "type": "Run",
+        "sport_type": "Run",
+        "start_date": "2023-01-01T10:00:00Z",
+        "start_date_local": "2023-01-01T10:00:00Z",
+        "timezone": "Europe/London",
+        "achievement_count": 2,
+        "kudos_count": 5,
+        "comment_count": 0,
+        "athlete_count": 1,
+        "photo_count": 0,
+        "trainer": False,
+        "commute": False,
+        "manual": False,
+        "private": False,
+        "flagged": False,
+        "average_speed": 4.167,
+        "max_speed": 5.3,
+        "has_heartrate": True,
+        "average_heartrate": 140,
+        "max_heartrate": 160,
+    }
+    mock_response.json.return_value = [activity_data]
+    api._client.request.return_value = mock_response
+    
+    # Test get_activities
+    activities = await api.get_activities()
+    
+    # Verify request
+    api._client.request.assert_called_once()
+    args, kwargs = api._client.request.call_args
+    assert args[0] == "GET"
+    assert args[1] == "/athlete/activities"
+    assert kwargs["params"] == {"page": 1, "per_page": 30}
+    
+    # Verify response
+    assert len(activities) == 1
+    assert isinstance(activities[0], Activity)
+    assert activities[0].id == activity_data["id"]
+    assert activities[0].name == activity_data["name"]
+
+
+@pytest.mark.asyncio
+async def test_get_activity(api, mock_response):
+    # Setup mock response
+    activity_data = {
+        "id": 1234567890,
+        "name": "Morning Run",
+        "distance": 5000,
+        "moving_time": 1200,
+        "elapsed_time": 1300,
+        "total_elevation_gain": 50,
+        "type": "Run",
+        "sport_type": "Run",
+        "start_date": "2023-01-01T10:00:00Z",
+        "start_date_local": "2023-01-01T10:00:00Z",
+        "timezone": "Europe/London",
+        "achievement_count": 2,
+        "kudos_count": 5,
+        "comment_count": 0,
+        "athlete_count": 1,
+        "photo_count": 0,
+        "trainer": False,
+        "commute": False,
+        "manual": False,
+        "private": False,
+        "flagged": False,
+        "average_speed": 4.167,
+        "max_speed": 5.3,
+        "has_heartrate": True,
+        "average_heartrate": 140,
+        "max_heartrate": 160,
+        "athlete": {"id": 123},
+        "description": "Test description",
+    }
+    mock_response.json.return_value = activity_data
+    api._client.request.return_value = mock_response
+    
+    # Test get_activity
+    activity = await api.get_activity(1234567890)
+    
+    # Verify request
+    api._client.request.assert_called_once()
+    args, kwargs = api._client.request.call_args
+    assert args[0] == "GET"
+    assert args[1] == "/activities/1234567890"
+    
+    # Verify response
+    assert isinstance(activity, DetailedActivity)
+    assert activity.id == activity_data["id"]
+    assert activity.name == activity_data["name"]
+    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

@@ -0,0 +1,211 @@
+import pytest
+from unittest.mock import AsyncMock, MagicMock, patch
+
+from strava_mcp.server import mcp
+from strava_mcp.models import Activity, DetailedActivity, SegmentEffort, Leaderboard
+
+
+class MockContext:
+    """Mock MCP context for testing."""
+    
+    def __init__(self, service):
+        self.request_context = MagicMock()
+        self.request_context.lifespan_context = {"service": service}
+
+
+@pytest.fixture
+def mock_service():
+    mock = AsyncMock()
+    mock.get_activities = AsyncMock()
+    mock.get_activity = AsyncMock()
+    mock.get_activity_segments = AsyncMock()
+    mock.get_segment_leaderboard = AsyncMock()
+    return mock
+
+
+@pytest.fixture
+def mock_ctx(mock_service):
+    return MockContext(mock_service)
+
+
+@pytest.mark.asyncio
+async def test_get_user_activities(mock_ctx, mock_service):
+    # Setup mock data
+    mock_activity = Activity(
+        id=1234567890,
+        name="Morning Run",
+        distance=5000,
+        moving_time=1200,
+        elapsed_time=1300,
+        total_elevation_gain=50,
+        type="Run",
+        sport_type="Run",
+        start_date="2023-01-01T10:00:00Z",
+        start_date_local="2023-01-01T10:00:00Z",
+        timezone="Europe/London",
+        achievement_count=2,
+        kudos_count=5,
+        comment_count=0,
+        athlete_count=1,
+        photo_count=0,
+        trainer=False,
+        commute=False,
+        manual=False,
+        private=False,
+        flagged=False,
+        average_speed=4.167,
+        max_speed=5.3,
+        has_heartrate=True,
+        average_heartrate=140,
+        max_heartrate=160,
+    )
+    mock_service.get_activities.return_value = [mock_activity]
+    
+    # Test tool
+    from strava_mcp.server import get_user_activities
+    result = await get_user_activities(mock_ctx)
+    
+    # Verify service call
+    mock_service.get_activities.assert_called_once_with(None, None, 1, 30)
+    
+    # Verify result
+    assert len(result) == 1
+    assert result[0]["id"] == mock_activity.id
+    assert result[0]["name"] == mock_activity.name
+
+
+@pytest.mark.asyncio
+async def test_get_activity(mock_ctx, mock_service):
+    # Setup mock data
+    mock_activity = DetailedActivity(
+        id=1234567890,
+        name="Morning Run",
+        distance=5000,
+        moving_time=1200,
+        elapsed_time=1300,
+        total_elevation_gain=50,
+        type="Run",
+        sport_type="Run",
+        start_date="2023-01-01T10:00:00Z",
+        start_date_local="2023-01-01T10:00:00Z",
+        timezone="Europe/London",
+        achievement_count=2,
+        kudos_count=5,
+        comment_count=0,
+        athlete_count=1,
+        photo_count=0,
+        trainer=False,
+        commute=False,
+        manual=False,
+        private=False,
+        flagged=False,
+        average_speed=4.167,
+        max_speed=5.3,
+        has_heartrate=True,
+        average_heartrate=140,
+        max_heartrate=160,
+        athlete={"id": 123},
+        description="Test description",
+    )
+    mock_service.get_activity.return_value = mock_activity
+    
+    # Test tool
+    from strava_mcp.server import get_activity
+    result = await get_activity(mock_ctx, 1234567890)
+    
+    # Verify service call
+    mock_service.get_activity.assert_called_once_with(1234567890, False)
+    
+    # Verify result
+    assert result["id"] == mock_activity.id
+    assert result["name"] == mock_activity.name
+    assert result["description"] == mock_activity.description
+
+
+@pytest.mark.asyncio
+async def test_get_activity_segments(mock_ctx, mock_service):
+    # Setup mock data
+    mock_segment = SegmentEffort(
+        id=67890,
+        activity_id=1234567890,
+        segment_id=12345,
+        name="Test Segment",
+        elapsed_time=180,
+        moving_time=180,
+        start_date="2023-01-01T10:05:00Z",
+        start_date_local="2023-01-01T10:05:00Z",
+        distance=1000,
+        athlete={"id": 123},
+        segment={
+            "id": 12345,
+            "name": "Test Segment",
+            "activity_type": "Run",
+            "distance": 1000,
+            "average_grade": 5.0,
+            "maximum_grade": 10.0,
+            "elevation_high": 200,
+            "elevation_low": 150,
+            "total_elevation_gain": 50,
+            "start_latlng": [51.5, -0.1],
+            "end_latlng": [51.5, -0.2],
+            "climb_category": 0,
+            "private": False,
+            "starred": False,
+        },
+    )
+    mock_service.get_activity_segments.return_value = [mock_segment]
+    
+    # Test tool
+    from strava_mcp.server import get_activity_segments
+    result = await get_activity_segments(mock_ctx, 1234567890)
+    
+    # Verify service call
+    mock_service.get_activity_segments.assert_called_once_with(1234567890)
+    
+    # Verify result
+    assert len(result) == 1
+    assert result[0]["id"] == mock_segment.id
+    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

@@ -0,0 +1,204 @@
+import pytest
+from unittest.mock import AsyncMock, MagicMock, patch
+
+from strava_mcp.config import StravaSettings
+from strava_mcp.service import StravaService
+from strava_mcp.models import Activity, DetailedActivity, SegmentEffort, Leaderboard
+
+
+@pytest.fixture
+def settings():
+    return StravaSettings(
+        client_id="test_client_id",
+        client_secret="test_client_secret",
+        refresh_token="test_refresh_token",
+    )
+
+
+@pytest.fixture
+def mock_api():
+    mock = AsyncMock()
+    mock.get_activities = AsyncMock()
+    mock.get_activity = AsyncMock()
+    mock.get_activity_segments = AsyncMock()
+    mock.get_segment_leaderboard = AsyncMock()
+    return mock
+
+
+@pytest.fixture
+def service(settings, mock_api):
+    with patch("strava_mcp.service.StravaAPI", return_value=mock_api):
+        service = StravaService(settings)
+        yield service
+
+
+@pytest.mark.asyncio
+async def test_get_activities(service, mock_api):
+    # Setup mocked data
+    mock_activity = Activity(
+        id=1234567890,
+        name="Morning Run",
+        distance=5000,
+        moving_time=1200,
+        elapsed_time=1300,
+        total_elevation_gain=50,
+        type="Run",
+        sport_type="Run",
+        start_date="2023-01-01T10:00:00Z",
+        start_date_local="2023-01-01T10:00:00Z",
+        timezone="Europe/London",
+        achievement_count=2,
+        kudos_count=5,
+        comment_count=0,
+        athlete_count=1,
+        photo_count=0,
+        trainer=False,
+        commute=False,
+        manual=False,
+        private=False,
+        flagged=False,
+        average_speed=4.167,
+        max_speed=5.3,
+        has_heartrate=True,
+        average_heartrate=140,
+        max_heartrate=160,
+    )
+    mock_api.get_activities.return_value = [mock_activity]
+    
+    # Test get_activities
+    activities = await service.get_activities()
+    
+    # Verify API call
+    mock_api.get_activities.assert_called_once_with(None, None, 1, 30)
+    
+    # Verify response
+    assert len(activities) == 1
+    assert activities[0] == mock_activity
+
+
+@pytest.mark.asyncio
+async def test_get_activity(service, mock_api):
+    # Setup mocked data
+    mock_activity = DetailedActivity(
+        id=1234567890,
+        name="Morning Run",
+        distance=5000,
+        moving_time=1200,
+        elapsed_time=1300,
+        total_elevation_gain=50,
+        type="Run",
+        sport_type="Run",
+        start_date="2023-01-01T10:00:00Z",
+        start_date_local="2023-01-01T10:00:00Z",
+        timezone="Europe/London",
+        achievement_count=2,
+        kudos_count=5,
+        comment_count=0,
+        athlete_count=1,
+        photo_count=0,
+        trainer=False,
+        commute=False,
+        manual=False,
+        private=False,
+        flagged=False,
+        average_speed=4.167,
+        max_speed=5.3,
+        has_heartrate=True,
+        average_heartrate=140,
+        max_heartrate=160,
+        athlete={"id": 123},
+        description="Test description",
+    )
+    mock_api.get_activity.return_value = mock_activity
+    
+    # Test get_activity
+    activity = await service.get_activity(1234567890)
+    
+    # Verify API call
+    mock_api.get_activity.assert_called_once_with(1234567890, False)
+    
+    # Verify response
+    assert activity == mock_activity
+
+
+@pytest.mark.asyncio
+async def test_get_activity_segments(service, mock_api):
+    # Setup mocked data
+    mock_segment = SegmentEffort(
+        id=67890,
+        activity_id=1234567890,
+        segment_id=12345,
+        name="Test Segment",
+        elapsed_time=180,
+        moving_time=180,
+        start_date="2023-01-01T10:05:00Z",
+        start_date_local="2023-01-01T10:05:00Z",
+        distance=1000,
+        athlete={"id": 123},
+        segment={
+            "id": 12345,
+            "name": "Test Segment",
+            "activity_type": "Run",
+            "distance": 1000,
+            "average_grade": 5.0,
+            "maximum_grade": 10.0,
+            "elevation_high": 200,
+            "elevation_low": 150,
+            "total_elevation_gain": 50,
+            "start_latlng": [51.5, -0.1],
+            "end_latlng": [51.5, -0.2],
+            "climb_category": 0,
+            "private": False,
+            "starred": False,
+        },
+    )
+    mock_api.get_activity_segments.return_value = [mock_segment]
+    
+    # Test get_activity_segments
+    segments = await service.get_activity_segments(1234567890)
+    
+    # Verify API call
+    mock_api.get_activity_segments.assert_called_once_with(1234567890)
+    
+    # Verify response
+    assert len(segments) == 1
+    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

uv.lock

@@ -562,6 +562,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/30/3d/64ad57c803f1fa1e963a7946b6e0fea4a70df53c1a7fed304586539c2bac/pytest-8.3.5-py3-none-any.whl", hash = "sha256:c69214aa47deac29fad6c2a4f590b9c4a9fdb16a403176fe154b79c0b4d4d820", size = 343634 },
 ]
 
+[[package]]
+name = "pytest-asyncio"
+version = "0.25.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f2/a8/ecbc8ede70921dd2f544ab1cadd3ff3bf842af27f87bbdea774c7baa1d38/pytest_asyncio-0.25.3.tar.gz", hash = "sha256:fc1da2cf9f125ada7e710b4ddad05518d4cee187ae9412e9ac9271003497f07a", size = 54239 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/67/17/3493c5624e48fd97156ebaec380dcaafee9506d7e2c46218ceebbb57d7de/pytest_asyncio-0.25.3-py3-none-any.whl", hash = "sha256:9e89518e0f9bd08928f97a3482fdc4e244df17529460bc038291ccaf8f85c7c3", size = 19467 },
+]
+
 [[package]]
 name = "pytest-mock"
 version = "3.14.0"
@@ -730,6 +742,7 @@ dev = [
     { name = "devtools" },
     { name = "ipykernel" },
     { name = "pytest" },
+    { name = "pytest-asyncio" },
     { name = "pytest-mock" },
 ]
 
@@ -746,6 +759,7 @@ dev = [
     { name = "devtools", specifier = ">=0.12.2" },
     { name = "ipykernel", specifier = ">=6.29.5" },
     { name = "pytest", specifier = ">=8.3.5" },
+    { name = "pytest-asyncio", specifier = ">=0.23.5" },
     { name = "pytest-mock", specifier = ">=3.14.0" },
 ]