sweatstack 0.72.0__tar.gz → 0.74.0__tar.gz

{sweatstack-0.72.0 → sweatstack-0.74.0}/.claude/settings.local.json

@@ -18,7 +18,8 @@
       "Bash(ls:*)",
       "Bash(git:*)",
       "Bash(python3:*)",
-      "Bash(test:*)"
+      "Bash(test:*)",
+      "Bash(uv run:*)"
     ],
     "deny": []
   }

{sweatstack-0.72.0 → sweatstack-0.74.0}/.claude/skills/sweatstack-python/client.md

@@ -8,6 +8,9 @@
 - [Mean-Max and AWD](#mean-max-and-awd)
 - [Longitudinal Data](#longitudinal-data)
 - [Traces](#traces)
+- [Tests](#tests)
+- [Dailies](#dailies-daily-health-metrics)
+- [App Metadata](#app-metadata)
 - [Profile](#profile)
 - [Users and Teams](#users-and-teams)
 - [User Delegation](#user-delegation)
@@ -136,6 +139,7 @@ The DataFrame has a timezone-aware datetime index and includes an `activity_id`
 import sweatstack
 sweatstack.enable_cache()                    # platform cache dir
 sweatstack.enable_cache(path="./my_cache")   # custom dir
+client.clear_cache()                         # remove all cached data for current user
 # Use fixed end dates (not "today") to get stable cache hits
 df = client.get_longitudinal_data(sports=[Sport.cycling], start=date(2025, 1, 1), end=date(2025, 3, 31))
 df = client.get_longitudinal_mean_max(sports=[Sport.cycling], metric="power", start=date(2025, 1, 1))
@@ -161,6 +165,104 @@ trace = client.create_trace(
 )
 ```
 
+## Tests
+
+Fitness assessments/evaluations with structured physiological results.
+
+```python
+# List tests (returns list[TestSummary])
+tests = client.get_tests(
+    start=date(2025, 1, 1),           # optional
+    end=date(2025, 12, 31),           # optional
+    sports=[Sport.cycling],            # optional
+    tags=["lab"],                      # optional
+    created_by="app_id",              # optional, filter by creator app
+    limit=50,                          # default 50
+)
+
+# As DataFrame (results column gets normalized into flat columns like results.vo2max)
+df = client.get_tests(as_dataframe=True)
+
+# Single test by ID (returns TestDetails with resolved traces + overlapping activities)
+test = client.get_test("test_id")
+
+# Create a test
+from sweatstack import TestResults, Marker
+test = client.create_test(
+    sport=Sport.cycling,
+    start=datetime(2025, 6, 1, 9, 0),
+    title="Lab test Q2",
+    results=TestResults(
+        first_threshold=Marker(power=200, heart_rate=140),
+        second_threshold=Marker(power=280, heart_rate=170),
+        vo2max=4500.0,
+        critical_power=260,
+    ),
+    tags=["lab"],
+)
+
+# Update a test (full replace — fields not provided are set to null)
+client.update_test(
+    test.id,
+    sport=Sport.cycling,
+    start=test.start,
+    title="Lab test Q2 (revised)",
+    results=test.results,  # must re-pass to keep existing results
+)
+
+# Delete a test
+client.delete_test("test_id")
+```
+
+## Dailies (Daily Health Metrics)
+
+```python
+from sweatstack import DailyMeasure
+
+# Get daily values over a date range (returns list[DailyResponse])
+dailies = client.get_dailies(
+    DailyMeasure.body_mass,
+    start=date(2026, 1, 1),
+    end=date(2026, 3, 31),
+    interpolate=True,            # default; server fills gaps
+)
+
+# As DataFrame (date as index)
+df = client.get_dailies(DailyMeasure.body_mass, start=date(2026, 1, 1), end=date(2026, 3, 31), as_dataframe=True)
+
+# Set a daily value (upsert — creates or updates)
+daily = client.set_daily(DailyMeasure.body_mass, date=date(2026, 4, 1), value=75.2)
+
+# Delete a daily value
+client.delete_daily(DailyMeasure.body_mass, date=date(2026, 4, 1))
+```
+
+Available measures: `body_mass`, `body_fat_pct`, `resting_hr`, `hrv`, `sleep_duration`, `sleep_altitude`, `menstrual_cycle_day`. The `measure` parameter is positional (part of the URL path). With `interpolate=False`, missing dates return `value=None, source="missing"`.
+
+## App Metadata
+
+Store arbitrary JSON data on entities, scoped per app. Requires an app token (token with `aud` claim).
+
+```python
+# Set metadata on an activity (full replace, max 1KB)
+client.set_activity_app_metadata("activity_id", data={"score": 8.5, "notes": "good"})
+
+# Delete it
+client.delete_activity_app_metadata("activity_id")
+
+# Same pattern for traces, tests, and the current user
+client.set_trace_app_metadata("trace_id", data={"source": "lab"})
+client.set_test_app_metadata("test_id", data={"protocol": "ramp"})
+client.set_user_app_metadata(data={"preferences": {"unit": "metric"}})  # max 4KB
+
+# Delete
+client.delete_trace_app_metadata("trace_id")
+client.delete_test_app_metadata("test_id")
+client.delete_user_app_metadata()
+```
+
+Metadata appears as `app_metadata` on entity responses when accessed via app token.
+
 ## Profile
 
 ```python
@@ -184,7 +286,13 @@ user = client.get_user("abc123", search_mode="id")
 # Create a managed user (no login credentials)
 user = client.create_user(first_name="John", last_name="Doe")
 
-# Team management
+# List teams you're a member/owner of
+teams = client.get_teams()                # list[TeamResponse] with .role
+
+# List teams you've authorized to access your data
+authorized = client.get_authorized_teams()  # list[AuthorizedTeamResponse] with .scopes
+
+# Team user management
 team_users = client.get_team_users(team_id="team_abc")
 athlete = client.get_team_user(team_id="team_abc", user="john")  # by name or ID
 client.authorize_team(team_id="team_abc", scopes=[Scope.data_read])
@@ -264,6 +372,7 @@ df = sweatstack.get_latest_activity_data()
 - **`start` is required for longitudinal endpoints.** Unlike `get_activities()` where all filters are optional.
 - **`sport` (singular) vs `sports` (list):** `get_latest_activity(sport=...)` and `create_trace(sport=...)` take a single sport. All other methods that filter by sport use `sports=[...]` (list). The singular `sport` parameter on longitudinal methods is deprecated.
 - **DataFrames have standard dtypes.** The library converts API-optimized types (Int16, float16) to float64/datetime64[ns] automatically.
-- **`as_dataframe=True`** is available on `get_activities()` and `get_traces()`. Time-series methods (`get_activity_data`, `get_longitudinal_data`, etc.) always return DataFrames.
+- **`as_dataframe=True`** is available on `get_activities()`, `get_traces()`, `get_tests()`, and `get_dailies()`. Time-series methods (`get_activity_data`, `get_longitudinal_data`, etc.) always return DataFrames.
+- **`update_test()` is a full replace.** Omitted optional fields are set to null. Always re-pass all fields you want to keep (e.g. `results=test.results`).
 - **`summary` fields are optional.** Always null-check: `activity.summary.power.mean if activity.summary and activity.summary.power else None`.
 - **`metrics` on ActivitySummary** lists available data streams, not the data itself. Use to check availability before calling `get_activity_data()`.

{sweatstack-0.72.0 → sweatstack-0.74.0}/CHANGELOG.md

@@ -6,6 +6,20 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 
+## [0.74.0] - 2026-04-22
+
+### Added
+- Team listing — `get_teams()` returns teams you own or belong to, `get_authorized_teams()` returns teams you've granted data access to.
+
+
+## [0.73.0] - 2026-04-09
+
+### Added
+- Full support for fitness tests — create, retrieve, update, and delete physiological assessments (threshold tests, VO2max tests, etc.) and their results.
+- App metadata — store and retrieve per-app JSON data on activities, traces, tests, and users.
+- Dailies — get, set, and delete daily health metrics (body mass, HRV, resting HR, etc.) with optional server-side interpolation.
+
+
 ## [0.72.0] - 2026-03-13
 
 ### Added

{sweatstack-0.72.0 → sweatstack-0.74.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sweatstack
-Version: 0.72.0
+Version: 0.74.0
 Summary: The official Python client for SweatStack
 Project-URL: Homepage, https://sweatstack.no
 Project-URL: Documentation, https://developer.sweatstack.no/getting-started/

sweatstack-0.74.0/plans/001a_tests.md

@@ -0,0 +1,190 @@
+# Plan: Add Tests (Fitness Assessments) to Python Client
+
+## Summary
+
+Add full CRUD support for the Tests resource - fitness assessments/evaluations containing structured physiological results (thresholds, VO2max, critical power, etc.).
+
+## Code Quality Requirements
+
+All code must be extremely clean, robust and maintainable:
+- Follow existing patterns and conventions exactly (keyword-only params, enum handling, error handling, docstrings)
+- Comprehensive type hints throughout
+- Clear, concise docstrings matching the existing style (Args, Returns, Raises)
+- No shortcuts, no dead code, no TODOs left behind
+
+## Step 1: Generate schemas
+
+Regenerate `openapi_schemas.py` from the running backend (must be running at `localhost:8080`):
+
+```bash
+uv run generate-response-models
+```
+
+This runs `datamodel-code-generator` against the OpenAPI spec (see `src/sweatstack/cli.py`). It auto-generates all Pydantic models including `TestSummary`, `TestDetails`, `TestResults`, `Marker`, `DailyMeasure`, `DailyResponse`, etc.
+
+This step is shared across all three plans (001a/b/c). Only needs to run once.
+
+## Step 2: Re-export new schemas from `schemas.py`
+
+Add new models to the imports in `schemas.py` (which re-exports from `openapi_schemas.py`).
+
+New exports needed:
+- `TestSummary`, `TestDetails`, `TestResults`, `Marker`
+
+These then become available via `from sweatstack import TestSummary` etc. since `__init__.py` is just `from .client import *` and `client.py` imports from `schemas.py`.
+
+No `DailyMeasure` enum enhancements here - that belongs to plan 001c.
+
+## Step 3: Add Tests methods to `client.py`
+
+Follow the exact patterns established by activities and traces. Import new schemas in `client.py` from `schemas.py`.
+
+### List with pagination generator (follows `_get_activities_generator` / `get_activities` pattern)
+
+```python
+def _get_tests_generator(
+    self,
+    *,
+    start: date | None = None,
+    end: date | None = None,
+    sports: list[Sport | str] | None = None,
+    tags: list[str] | None = None,
+    created_by: str | None = None,
+    limit: int = 50,
+    offset: int = 0,
+) -> Generator[TestSummary, None, None]:
+    # Same structure as _get_activities_generator.
+    # default_limit = 50 (matches API default, unlike activities which use 100)
+    # Query params: start, end, sport (list), tags (list), created_by, limit, offset
+    # Yields TestSummary.model_validate(item) for each item
+```
+
+```python
+def get_tests(
+    self,
+    *,
+    start: date | None = None,
+    end: date | None = None,
+    sports: list[Sport | str] | None = None,
+    tags: list[str] | None = None,
+    created_by: str | None = None,
+    limit: int = 50,
+    offset: int = 0,
+    as_dataframe: bool = False,
+) -> list[TestSummary] | pd.DataFrame:
+    # Consumes generator into list.
+    # DataFrame conversion: model_dump() each item, then normalize the "results" column
+    # using _normalize_dataframe_column (same pattern as activities normalizing "summary").
+    # Empty result: use _create_empty_dataframe_from_model(TestSummary, normalize_columns=["results"])
+```
+
+### Get single test (follows `get_activity` pattern)
+
+```python
+def get_test(self, test_id: str) -> TestDetails:
+    # GET /api/v1/tests/{test_id}
+    # Returns TestDetails (includes resolved traces + overlapping activities)
+```
+
+### Create (follows `create_trace` pattern)
+
+```python
+def create_test(
+    self,
+    *,
+    sport: Sport | str,
+    start: datetime,
+    title: str | None = None,
+    end: datetime | None = None,
+    results: TestResults | None = None,
+    tags: list[str] | None = None,
+) -> TestSummary:
+    # POST /api/v1/tests/
+    # sport and start are required (matching the API)
+    # Convert sport enum via _enums_to_strings()
+    # Serialize: start/end via .isoformat(), results via .model_dump() if not None
+    # Return TestSummary.model_validate(response.json())
+```
+
+### Update (new pattern - first PUT/update in this client)
+
+```python
+def update_test(
+    self,
+    test_id: str,
+    *,
+    sport: Sport | str,
+    start: datetime,
+    title: str | None = None,
+    end: datetime | None = None,
+    results: TestResults | None = None,
+    tags: list[str] | None = None,
+) -> None:
+    # PUT /api/v1/tests/{test_id}
+    # Returns None (API returns {"message": "..."})
+    #
+    # Docstring must clearly state full-replace semantics:
+    # "Updates a test by replacing all fields. Fields not provided are set
+    # to null. To modify a single field, first fetch the test with
+    # get_test(), then pass all fields back."
+```
+
+### Delete (new pattern - first DELETE in this client)
+
+```python
+def delete_test(self, test_id: str) -> None:
+    # DELETE /api/v1/tests/{test_id}
+    # Returns None
+```
+
+## Step 4: Register singleton methods
+
+Add to `_generate_singleton_methods()`:
+```python
+"get_tests",
+"get_test",
+"create_test",
+"update_test",
+"delete_test",
+```
+
+## Step 5: Tests (pytest)
+
+Add `tests/test_tests.py`. Follow the existing testing style (see `test_dtype_conversion.py`, `test_webhooks.py`) - test pure logic without hitting the API.
+
+Focus on:
+- **Serialization round-trip**: Create a `TestResults` with `Marker` objects, serialize via `.model_dump()`, validate back via `TestSummary.model_validate()`. Verify nested structures survive the round-trip.
+- **DataFrame conversion**: Build a list of `TestSummary` objects, convert to DataFrame the same way `get_tests(as_dataframe=True)` would, verify the `results` column gets normalized into `results.first_threshold.power`, `results.vo2max` etc.
+- **Empty DataFrame**: Verify `_create_empty_dataframe_from_model(TestSummary, normalize_columns=["results"])` produces a valid empty DataFrame with the right column structure.
+- **Enum handling**: Verify `_enums_to_strings([Sport.cycling])` works for the sports param, and that string pass-through works.
+
+Don't test: HTTP calls, authentication, pagination logic (that's integration testing).
+
+## Step 6: Update skill docs
+
+Update `.claude/skills/sweatstack-python/client.md` with the new Tests methods.
+
+## API Reference
+
+| Method | Path | Query/Body | Response |
+|--------|------|------------|----------|
+| POST | `/api/v1/tests/` | Body: `{title?, sport, start, end?, results?, tags?}` | `TestSummary` |
+| GET | `/api/v1/tests/` | Query: `start?, end?, sport[]?, tags[]?, created_by?, limit, offset` | `TestSummary[]` |
+| GET | `/api/v1/tests/{test_id}` | - | `TestDetails` |
+| PUT | `/api/v1/tests/{test_id}` | Body: `{title?, sport, start, end?, results?, tags?}` (full replace) | `{"message": "..."}` |
+| DELETE | `/api/v1/tests/{test_id}` | - | `{"message": "..."}` |
+
+### Key Schema Details
+
+**TestResults** contains all-optional fields:
+- Thresholds: `first_threshold`, `second_threshold`, `fatmax`, `lt1`, `lt2`, `vt1`, `vt2`, `mlss` (each a `Marker`)
+- Capacity: `vo2max`, `vo2peak` (mL/min), `vlamax` (mmol/L/s), `heart_rate_max` (bpm), `critical_power` (W), `critical_speed` (m/s), `w_prime` (kJ), `d_prime` (m)
+- Economy: `economy` (mL O2/kg/km), `efficiency` (%)
+
+**Marker**: `power` (W), `speed` (m/s), `heart_rate` (bpm), `lactate` (mmol/L), `vo2` (mL/min)
+
+### Key Behaviors
+- `end` defaults to `start + 3h` server-side if omitted
+- TestDetails resolves traces by timestamp within window, activities by time overlap
+- App ownership: tests created via app token can only be modified/deleted by that app
+- Tags use AND logic for filtering, sports use OR logic

sweatstack-0.74.0/plans/001b_metadata.md

@@ -0,0 +1,121 @@
+# Plan: Add App Metadata to Python Client
+
+## Summary
+
+Add methods for managing per-app JSON metadata on activities, traces, tests, and users. These endpoints require an app token (a token with an `aud` claim) and allow apps to store arbitrary JSON data scoped to their application.
+
+## Code Quality Requirements
+
+All code must be extremely clean, robust and maintainable:
+- Follow existing patterns and conventions exactly
+- Consistent naming across the four entity types
+- DRY implementation via shared private helpers
+- Comprehensive type hints and docstrings
+
+## Prerequisites
+
+- Schema generation (`uv run generate-response-models`) must have been run (see 001a step 1). The `app_metadata` field appears on entity response schemas.
+- Plan 001a (Tests) should be completed first since test metadata endpoints reference the tests resource.
+
+## Step 1: Add private helpers to `client.py`
+
+All eight public methods do the same thing with different paths. Extract two private helpers to keep the implementation DRY:
+
+```python
+def _set_app_metadata(self, path: str, data: dict) -> None:
+    """PUT arbitrary JSON dict to an app-metadata endpoint."""
+    with self._http_client() as client:
+        response = client.put(url=path, json=data)
+        self._raise_for_status(response)
+
+def _delete_app_metadata(self, path: str) -> None:
+    """DELETE an app-metadata endpoint."""
+    with self._http_client() as client:
+        response = client.delete(url=path)
+        self._raise_for_status(response)
+```
+
+## Step 2: Add public App Metadata methods to `client.py`
+
+Eight methods, four entity types x two operations (set/delete). Each is a thin wrapper over the helpers.
+
+Naming convention: `set_*_app_metadata` / `delete_*_app_metadata` - uses "set" since PUT has full-replace semantics (not a partial merge), and includes "app" to match the API path (`/app-metadata`) and the response field name (`app_metadata`).
+
+```python
+def set_activity_app_metadata(self, activity_id: str, *, data: dict) -> None:
+    # PUT /api/v1/activities/{activity_id}/app-metadata
+    self._set_app_metadata(f"/api/v1/activities/{activity_id}/app-metadata", data)
+
+def delete_activity_app_metadata(self, activity_id: str) -> None:
+    # DELETE /api/v1/activities/{activity_id}/app-metadata
+    self._delete_app_metadata(f"/api/v1/activities/{activity_id}/app-metadata")
+
+def set_trace_app_metadata(self, trace_id: str, *, data: dict) -> None:
+def delete_trace_app_metadata(self, trace_id: str) -> None:
+
+def set_test_app_metadata(self, test_id: str, *, data: dict) -> None:
+def delete_test_app_metadata(self, test_id: str) -> None:
+
+def set_user_app_metadata(self, *, data: dict) -> None:
+    # PUT /api/v1/profile/app-metadata (no entity_id, operates on authenticated user)
+
+def delete_user_app_metadata(self) -> None:
+    # DELETE /api/v1/profile/app-metadata
+```
+
+**Implementation notes:**
+- `data` is keyword-only (after `*`) to be explicit about what's being sent
+- For entity methods, `entity_id` is positional (consistent with `get_activity(activity_id)` etc.)
+- All error handling delegated to `_raise_for_status`: 403 (no app token), 413 (over size limit), 422 (nesting too deep)
+- Each method gets a proper docstring despite being thin - the user-facing API should be self-documenting
+
+## Step 3: Register singleton methods
+
+Add all eight to `_generate_singleton_methods()`:
+```python
+"set_activity_app_metadata",
+"delete_activity_app_metadata",
+"set_trace_app_metadata",
+"delete_trace_app_metadata",
+"set_test_app_metadata",
+"delete_test_app_metadata",
+"set_user_app_metadata",
+"delete_user_app_metadata",
+```
+
+## Step 4: Tests (pytest)
+
+Add `tests/test_metadata.py`. Lightweight - the methods are thin wrappers, so there's not much pure logic to test.
+
+Focus on:
+- **Path construction**: Verify the correct API path is built for each entity type. Can test by checking the URL passed to the helper (or by testing the helpers directly with a mock/spy on `_http_client`).
+
+Don't over-test: these are simple PUT/DELETE wrappers. If the paths are correct and `_raise_for_status` is called, the methods are correct.
+
+## Step 5: Update skill docs
+
+Update `.claude/skills/sweatstack-python/client.md` with the new metadata methods.
+
+## Step 6: Changelog
+
+Add entries to the `[Unreleased]` section of `CHANGELOG.md`.
+
+## API Reference
+
+| Method | Path | Body | Size Limit | Response |
+|--------|------|------|------------|----------|
+| PUT | `/api/v1/activities/{id}/app-metadata` | JSON dict | 1KB | `{"message": "..."}` |
+| DELETE | `/api/v1/activities/{id}/app-metadata` | - | - | 204 |
+| PUT | `/api/v1/traces/{id}/app-metadata` | JSON dict | 1KB | `{"message": "..."}` |
+| DELETE | `/api/v1/traces/{id}/app-metadata` | - | - | 204 |
+| PUT | `/api/v1/tests/{id}/app-metadata` | JSON dict | 1KB | `{"message": "..."}` |
+| DELETE | `/api/v1/tests/{id}/app-metadata` | - | - | 204 |
+| PUT | `/api/v1/profile/app-metadata` | JSON dict | 4KB | `{"message": "..."}` |
+| DELETE | `/api/v1/profile/app-metadata` | - | - | 204 |
+
+### Key Behaviors
+- All require app token (token with `aud` claim) - 403 otherwise
+- PUT replaces the entire metadata dict (no partial merge)
+- Each app's metadata is isolated (apps can't see each other's metadata)
+- `app_metadata` field appears on entity responses only when accessed via app token
+- Metadata cascades on entity or app deletion

sweatstack-0.74.0/plans/001c_dailies.md

@@ -0,0 +1,165 @@
+# Plan: Add Dailies (Daily Health Metrics) to Python Client
+
+## Summary
+
+Add support for daily health/body metrics - time-series data like body mass, HRV, resting HR, etc. with server-side interpolation/estimation. Simple CRUD per measure with smart gap-filling on read.
+
+## Code Quality Requirements
+
+All code must be extremely clean, robust and maintainable:
+- Follow existing patterns and conventions exactly
+- Clean enum handling matching Sport/Metric patterns
+- Comprehensive type hints and docstrings
+
+## Step 1: Schemas
+
+### Generated schemas
+
+Schema generation (`uv run generate-response-models`) must have been run (see 001a step 1). This produces:
+
+- `DailyMeasure` enum: `body_mass`, `body_fat_pct`, `resting_hr`, `hrv`, `sleep_duration`, `sleep_altitude`, `menstrual_cycle_day`
+- `DailyResponse`: `date`, `value` (nullable float), `source` (str)
+
+### Enum enhancements in `schemas.py`
+
+Add `DailyMeasure` enhancements following the existing `Sport`/`Metric` pattern:
+- `display_name()` method (replace underscores with spaces)
+- `_missing_` classmethod handler for forward compatibility with new measures
+
+### Re-exports
+
+Add `DailyMeasure` and `DailyResponse` to the imports in `schemas.py` (from `openapi_schemas`) and to the imports in `client.py` (from `schemas`). They become available to users via `from sweatstack import DailyMeasure` since `__init__.py` is `from .client import *`.
+
+## Step 2: Add Dailies methods to `client.py`
+
+Three methods matching the three API endpoints.
+
+**Design decision: `measure` is positional.** This breaks the convention that list/create methods use keyword-only params, but it's justified: `measure` is part of the URL path (`/dailies/{measure}`), identifying which time-series resource to operate on. It's analogous to `get_activity(activity_id)` rather than to a filter parameter.
+
+**Design decision: `set_daily` not `create_daily`.** The API has upsert semantics (creates or updates). `create_daily` implies it would fail if the entry exists; `set_daily` honestly communicates "set this value for this date" regardless of prior state. This also aligns with `set_*_app_metadata` for other upsert operations in 001b.
+
+```python
+def get_dailies(
+    self,
+    measure: DailyMeasure | str,
+    *,
+    start: date,
+    end: date,
+    interpolate: bool = True,
+    as_dataframe: bool = False,
+) -> list[DailyResponse] | pd.DataFrame:
+    """Gets daily values for a measure over a date range.
+
+    Args:
+        measure: The daily measure to retrieve (e.g. DailyMeasure.body_mass).
+        start: Start date (inclusive).
+        end: End date (inclusive).
+        interpolate: Whether to apply server-side estimation/interpolation.
+            Defaults to True. When False, missing dates return value=None
+            with source="missing".
+        as_dataframe: Whether to return results as a pandas DataFrame.
+            Defaults to False.
+
+    Returns:
+        Either a list of DailyResponse objects or a pandas DataFrame with
+        date as index. Always returns one entry per date in the range.
+    """
+    # GET /api/v1/dailies/{measure}
+    # Convert measure enum to string for URL path
+    # Query: start, end, interpolate
+    # Parse response as list of DailyResponse
+    # DataFrame mode: set date as index for natural time-series usage
+
+def set_daily(
+    self,
+    measure: DailyMeasure | str,
+    *,
+    date: date,
+    value: float,
+) -> DailyResponse:
+    """Sets a daily value (creates or updates).
+
+    Args:
+        measure: The daily measure (e.g. DailyMeasure.body_mass).
+        date: The date for the measurement.
+        value: The measurement value.
+
+    Returns:
+        DailyResponse: The created/updated daily entry.
+    """
+    # POST /api/v1/dailies/{measure}
+    # Body: {date: date.isoformat(), value: value}
+
+def delete_daily(
+    self,
+    measure: DailyMeasure | str,
+    *,
+    date: date,
+) -> None:
+    """Deletes a daily value.
+
+    Args:
+        measure: The daily measure to delete.
+        date: The date of the entry to delete.
+
+    Raises:
+        HTTPStatusError: 404 if entry does not exist.
+    """
+    # DELETE /api/v1/dailies/{measure}?date={date.isoformat()}
+    # Returns None (API returns 204)
+```
+
+## Step 3: Register singleton methods
+
+Add to `_generate_singleton_methods()`:
+```python
+"get_dailies",
+"set_daily",
+"delete_daily",
+```
+
+## Step 4: Tests (pytest)
+
+Add `tests/test_dailies.py`. Follow existing style - test pure logic without hitting the API.
+
+Focus on:
+- **DailyMeasure enum enhancements**: Verify `display_name()` returns expected strings (e.g. `DailyMeasure.body_fat_pct.display_name()` -> `"body fat pct"`). Verify `_missing_` handles unknown values gracefully.
+- **DataFrame conversion**: Build a list of `DailyResponse` objects, convert to DataFrame the same way `get_dailies(as_dataframe=True)` would, verify date is set as index and columns are correct.
+- **Enum to string conversion**: Verify `DailyMeasure.body_mass` serializes to `"body_mass"` for the URL path.
+
+Don't test: HTTP calls, interpolation logic (that's server-side).
+
+## Step 5: Update skill docs
+
+Update `.claude/skills/sweatstack-python/client.md` with the new Dailies methods.
+
+## Step 6: Changelog
+
+Add entries to the `[Unreleased]` section of `CHANGELOG.md`.
+
+## API Reference
+
+| Method | Path | Query/Body | Response |
+|--------|------|------------|----------|
+| GET | `/api/v1/dailies/{measure}` | Query: `start` (date, required), `end` (date, required), `interpolate` (bool, default true) | `DailyResponse[]` |
+| POST | `/api/v1/dailies/{measure}` | Body: `{date, value}` | `DailyResponse` |
+| DELETE | `/api/v1/dailies/{measure}` | Query: `date` (date, required) | 204 |
+
+### Supported Measures
+
+| Measure | Unit | Interpolation Strategy |
+|---------|------|------------------------|
+| `body_mass` | kg | Linear interpolation + fill |
+| `body_fat_pct` | % | Linear interpolation + fill |
+| `resting_hr` | bpm | None (gaps shown) |
+| `hrv` | ms | None (gaps shown) |
+| `sleep_duration` | seconds | None (gaps shown) |
+| `sleep_altitude` | meters | Forward/backward fill |
+| `menstrual_cycle_day` | day | Auto-increment from 0 |
+
+### Key Behaviors
+- Composite key: (user, date, measure) - one value per measure per day
+- Source precedence: manual entries are never overwritten by integration imports
+- `interpolate=True`: server fills gaps using measure-specific strategy
+- `interpolate=False`: returns raw data with `{value: None, source: "missing"}` for gaps
+- Always returns exactly one entry per date in the requested range

{sweatstack-0.72.0 → sweatstack-0.74.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sweatstack"
-version = "0.72.0"
+version = "0.74.0"
 description = "The official Python client for SweatStack"
 readme = "README.md"
 license = "MIT"