sweatstack 0.80.0__tar.gz → 0.82.0__tar.gz

{sweatstack-0.80.0 → sweatstack-0.82.0}/.claude/settings.local.json

@@ -27,7 +27,11 @@
       "WebFetch(domain:pypi.org)",
       "WebFetch(domain:github.com)",
       "WebFetch(domain:raw.githubusercontent.com)",
-      "Bash(uv add *)"
+      "Bash(uv add *)",
+      "Bash(sed -n '42,50p' src/sweatstack/client.py)",
+      "Bash(sed -n '1017,1022p' src/sweatstack/client.py)",
+      "Bash(sed -i '' 's/sport=cycling\\\\.road&sport=cycling\\\\.tt/sport=cycling.road\\\\&sport=cycling.time_trial/' docs-dev/changelog.md)",
+      "Bash(sed -n '25p' docs-dev/changelog.md)"
     ],
     "deny": []
   }

{sweatstack-0.80.0 → sweatstack-0.82.0}/AGENTS.md

@@ -16,7 +16,7 @@ you add or change a surface, the default is to mirror the server:
 | `POST /api/v1/traces/`                  | `client.create_trace(...)`              |
 | `PUT /api/v1/traces/{id}` (full-replace)| `client.update_trace(trace_id, ...)`    |
 | `DELETE /api/v1/dailies/{id}`           | `client.delete_daily(daily_id)`         |
-| query param `?sport=cycling&sport=running` | `sports=[Sport.cycling, Sport.running]` |
+| query param `?sport=cycling&sport=running` | `sports=[Sport("cycling"), Sport("running")]` |
 | JSON body field `test_id`               | kwarg `test_id`                         |
 | OpenAPI enum value `"auto"`             | `TraceResolution.auto`                  |
 
@@ -44,7 +44,7 @@ and pagination shape. Don't redesign the API in Python.
 ```
 src/sweatstack/
 ├── openapi_schemas.py   # AUTO-GENERATED. Never hand-edit.
-├── schemas.py           # Re-exports + Enum._missing_ / display_name helpers.
+├── schemas.py           # Re-exports (incl. OST Sport/Modifier) + Metric/Scope/DailyMeasure helpers.
 ├── exceptions.py        # Public error contract. No httpx types leak.
 ├── client.py            # Single Client class + module-level singletons.
 ├── utils.py             # Dataframe / JWT helpers.
@@ -72,6 +72,10 @@ Skipping step 3 silently breaks the public surface. Same for new enums.
   bottom of `client.py`. Forgetting is silent.
 - **Enum-typed params accept `Enum | str`** and route through
   `_enums_to_strings`. Don't introduce strict-enum-only parameters.
+- **`Sport` is the OpenSportTaxonomy type** (`open_sport_taxonomy.Sport`), not a generated enum.
+  Construct with `Sport("cycling.road")` or `Sport.parse(value)`; serialise with `str(sport)`. Codegen
+  binds the `sport` field to OST's permissive `SportField` (cli.py `_bind_sport_to_ost`), so regen is
+  safe and `sport`-typed fields keep decoding to `Sport`.
 - **Tests are offline.** No network calls. Use `Client.__new__(Client)` to
   bypass init when you need an instance for a helper method.
 - **`update_*` methods are full-replace.** Document the silent-clear

{sweatstack-0.80.0 → sweatstack-0.82.0}/CHANGELOG.md

@@ -5,6 +5,72 @@ All notable changes to this project will be documented in this file.
 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.82.0] - 2026-06-16
+
+### Added
+
+- `get_longitudinal_mean_max(after=...)`: fatigue-state mean-max. Pass one or more thresholds (kJ of work for `power`; metres of distance for `speed`, experimental) to get, per state, the mean-max over the portion of each ride after that threshold. The returned DataFrame stays metric-indexed with an added `after` column. Max 5 states; the date range is capped at 1 year when `after` is used.
+
+## [0.81.0] - 2026-06-16
+
+The SweatStack API has fully adopted [OpenSportTaxonomy](https://github.com/SweatStack/open-sport-taxonomy)
+(OST), and so has this client. `sweatstack.Sport` is now the OST `Sport` type instead of a bespoke enum.
+This is a **breaking change** for code that uses `Sport`.
+
+### Changed (breaking)
+- `sweatstack.Sport` is now `open_sport_taxonomy.Sport` — a rich type (`.code`, `.label`, `.modifiers`,
+  `.parent`, `.is_subsport_of()`, `.resolve()`, `Sport.parse()`, `Sport.all()`) rather than a string
+  enum. There are no `Sport.cycling_road`-style members; construct a known sport with
+  `Sport("cycling.road")` or parse external input with `Sport.parse(value)`. The bespoke helpers
+  (`root_sport()`, `parent_sport()`, `is_sub_sport_of()`, `is_root_sport()`, `display_name()`) are
+  removed in favour of OST's native API.
+- Sport values are now OST values, e.g. `cycling.trainer` → `cycling+stationary`, `cycling.tt` →
+  `cycling.time_trial`, `cross_country_skiing` → `xc_skiing`, `unknown` → `generic`. Response data,
+  longitudinal DataFrames and `get_sports()` all return OST values; requests send OST values.
+
+### Added
+- `sweatstack.Modifier` (re-exported from OpenSportTaxonomy) for inspecting sport modifiers. (For typed
+  sport annotations, `StandardSport` is available from `open_sport_taxonomy` directly.)
+- `open-sport-taxonomy[pydantic]` is now a runtime dependency. Response models consume `sport` via OST's
+  permissive `SportField`, so sports newer than the bundled taxonomy are preserved rather than rejected.
+
+### Migration
+Hand the following prompt to a coding agent, or apply it by hand:
+
+```text
+Migrate this codebase to sweatstack 0.81.0, which replaces its custom `Sport` enum with the
+OpenSportTaxonomy type (`open_sport_taxonomy.Sport`). `from sweatstack import Sport` is now that type.
+
+1. Construction (there are no enum members like `Sport.cycling_road`):
+   - Known sport in app code -> `Sport("cycling.road")` (raises on an unknown code/modifier).
+   - From an API/string value -> `Sport.parse(value)` (permissive; never raises; preserves unknown).
+   - For typed annotations/autocomplete of the standard catalogue ->
+     `from open_sport_taxonomy import StandardSport` (a Literal).
+
+2. These sport VALUES changed; update hardcoded strings or members:
+   cycling.trainer->cycling+stationary, running.treadmill->running+stationary,
+   rowing.ergometer->rowing+stationary, cycling.tt->cycling.time_trial,
+   cycling.mountainbike->cycling.mountain, cross_country_skiing[.classic|.skate]->xc_skiing[...],
+   unknown->generic. ("stationary" etc. are now modifiers, appended with `+`; see sport.modifiers.)
+
+3. Methods / attributes:
+   Sport.cycling_road          -> Sport("cycling.road")
+   sport.value                 -> str(sport)  (canonical, incl. modifiers) or sport.code
+   sport.display_name()        -> sport.label
+   sport.parent_sport()        -> sport.parent
+   sport.is_sub_sport_of(x)    -> sport.is_subsport_of(x)   (x is a single Sport; for a list use
+                                  any(sport.is_subsport_of(s) for s in xs))
+   sport.root_sport()          -> Sport(sport.code.split(".")[0])
+   sport.is_root_sport()       -> ("." not in sport.code and not sport.modifiers)
+   for s in Sport: ...         -> for s in Sport.all(): ...
+
+4. Equality works: `activity.sport == Sport("cycling+stationary")`. Compare against the NEW value.
+
+After editing, run the test suite and fix any remaining references. Do not add a compatibility shim;
+migrate call sites to the OST API directly.
+```
+
+
 ## [0.80.0] - 2026-06-12
 
 ### Changed

{sweatstack-0.80.0 → sweatstack-0.82.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sweatstack
-Version: 0.80.0
+Version: 0.82.0
 Summary: The official Python client for SweatStack
 Project-URL: Homepage, https://sweatstack.no
 Project-URL: Documentation, https://docs.sweatstack.no/getting-started/
@@ -23,6 +23,7 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.10
 Requires-Dist: email-validator>=2.2.0
 Requires-Dist: httpx>=0.28.1
+Requires-Dist: open-sport-taxonomy[pydantic]>=0.10.0
 Requires-Dist: pandas>=2.2.3
 Requires-Dist: platformdirs>=4.0.0
 Requires-Dist: pyarrow>=18.0.0
@@ -43,3 +44,7 @@ Description-Content-Type: text/markdown
 This is the official Python client library for SweatStack.
 
 Documentation can be found [here](https://docs.sweatstack.no/getting-started/).
+
+Sports follow [OpenSportTaxonomy](https://open-sport-taxonomy.sweatstack.no): `sweatstack.Sport` is the
+OST `Sport` type. See the [OpenSportTaxonomy Python guide](https://github.com/SweatStack/open-sport-taxonomy/blob/main/python/README.md)
+for the full `Sport` API.

sweatstack-0.82.0/README.md

@@ -0,0 +1,9 @@
+# SweatStack Python client library
+
+This is the official Python client library for SweatStack.
+
+Documentation can be found [here](https://docs.sweatstack.no/getting-started/).
+
+Sports follow [OpenSportTaxonomy](https://open-sport-taxonomy.sweatstack.no): `sweatstack.Sport` is the
+OST `Sport` type. See the [OpenSportTaxonomy Python guide](https://github.com/SweatStack/open-sport-taxonomy/blob/main/python/README.md)
+for the full `Sport` API.

{sweatstack-0.80.0 → sweatstack-0.82.0}/docs/everything.rst

@@ -151,8 +151,13 @@ sweatstack.schemas
 Sport
 ~~~~~
 
-.. autoclass:: sweatstack.schemas.Sport
-    :members: root_sport, parent_sport, is_sub_sport_of, is_root_sport, display_name
+``sweatstack.Sport`` is the `OpenSportTaxonomy <https://github.com/SweatStack/open-sport-taxonomy>`_
+``Sport`` type. Construct a known sport with ``Sport("cycling.road")`` and parse external/API input
+with ``Sport.parse(value)``. See the OpenSportTaxonomy documentation for the full API (``code``,
+``label``, ``modifiers``, ``parent``, ``disciplines``, ``is_subsport_of``, ``resolve``, ``all``).
+
+.. autoclass:: sweatstack.Sport
+    :members: parse, resolve, is_subsport_of, all
     :undoc-members:
 
 Metric

{sweatstack-0.80.0 → sweatstack-0.82.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sweatstack"
-version = "0.80.0"
+version = "0.82.0"
 description = "The official Python client for SweatStack"
 readme = "README.md"
 license = "MIT"
@@ -23,6 +23,7 @@ classifiers = [
 dependencies = [
     "email-validator>=2.2.0",
     "httpx>=0.28.1",
+    "open-sport-taxonomy[pydantic]>=0.10.0",
     "pandas>=2.2.3",
     "platformdirs>=4.0.0",
     "pyarrow>=18.0.0",

sweatstack-0.82.0/src/sweatstack/cli.py

@@ -0,0 +1,48 @@
+import ast
+from pathlib import Path
+
+import httpx
+
+from datamodel_code_generator import InputFileType, generate
+from datamodel_code_generator import DataModelType
+
+
+def _bind_sport_to_ost(path: Path) -> None:
+    """Replace the codegen'd ``Sport`` enum with OpenSportTaxonomy's pydantic field.
+
+    The API speaks OpenSportTaxonomy, so ``sport`` fields are consumed via OST's permissive
+    ``SportField``: it validates inbound values to an ``open_sport_taxonomy.Sport`` and serialises
+    back to the canonical wire string, tolerating sports newer than the bundled taxonomy. Anchored on
+    the AST (not a text match) so it survives regeneration; the import is injected where the class was,
+    safely past the module's ``from __future__`` header.
+    """
+    src = path.read_text()
+    cls = next(
+        node for node in ast.parse(src).body
+        if isinstance(node, ast.ClassDef) and node.name == "Sport"  # the enum carries no decorators
+    )
+    lines = src.splitlines(keepends=True)
+    lines[cls.lineno - 1:cls.end_lineno] = [
+        "from open_sport_taxonomy.pydantic import SportField as Sport  # OST sport type (see schemas.py)\n",
+    ]
+    path.write_text("".join(lines))
+
+
+def generate_response_models():
+    response = httpx.get("http://localhost:8080/openapi.json")
+    response.raise_for_status()
+    output_directory = Path(__file__).parent
+    output = Path(output_directory / "openapi_schemas.py")
+    output.unlink(missing_ok=True)
+    generate(
+        response.text,
+        input_file_type=InputFileType.OpenAPI,
+        input_filename="openapi.json",
+        output=output,
+        # set up the output model types
+        output_model_type=DataModelType.PydanticV2BaseModel,
+    )
+    _bind_sport_to_ost(output)
+
+    model = output.read_text()
+    print(model)

{sweatstack-0.80.0 → sweatstack-0.82.0}/src/sweatstack/client.py

@@ -42,11 +42,10 @@ from .exceptions import (
 from .schemas import (
     ActivityDetails, ActivitySummary, ApplicationMemberRole, AuthorizedTeamResponse,
     BackfillStatus, DailyMeasure, DailyResponse,
-    Marker, Metric, Scope, Sport,
+    Marker, Metric, Modifier, Scope, Sport,
     TeamResponse, TestDetails, TestResults, TestSummary, TokenResponse, TraceDetails,
     TraceResolution, UserInfoResponse, UserResponse, UserSummary
 )
-from .schemas import _sport_to_wire
 from .utils import convert_to_standard_dtypes, decode_jwt_body, make_dataframe_streamlit_compatible
 
 logger = logging.getLogger(__name__)
@@ -1016,9 +1015,15 @@ class Client(_OAuth2Mixin, _DelegationMixin, _TokenStorageMixin, _LocalCacheMixi
             return text if text else None
 
     def _enums_to_strings(self, values: list[Enum | str]) -> list[str]:
-        # Sport filters get a lossy forward-compat fallback (_sport_to_wire); it is a no-op for every
-        # other enum/string value.
-        return [_sport_to_wire(value.value if isinstance(value, Enum) else value) for value in values]
+        out = []
+        for value in values:
+            if isinstance(value, Sport):
+                out.append(str(value))           # OST Sport -> canonical wire string
+            elif isinstance(value, Enum):
+                out.append(value.value)
+            else:
+                out.append(value)
+        return out
 
     def _get_activities_generator(
         self,
@@ -1459,6 +1464,7 @@ class Client(_OAuth2Mixin, _DelegationMixin, _TokenStorageMixin, _LocalCacheMixi
         end: date | str | None = None,
         date: date | str | None = None,
         window_days: int | None = None,
+        after: list[float] | float | None = None,
     ) -> pd.DataFrame:
         """Gets the mean-max curve for one or more sports and a metric.
 
@@ -1470,9 +1476,17 @@ class Client(_OAuth2Mixin, _DelegationMixin, _TokenStorageMixin, _LocalCacheMixi
             end: End of the date range (defaults to today).
             date: Deprecated since 0.70.0. Use ``start`` and ``end`` instead.
             window_days: Deprecated since 0.70.0. Use ``start`` and ``end`` instead.
+            after: One or more fatigue states. For each value, the mean-max is computed
+                over the portion of each ride after that much accumulated work (kJ, for
+                ``power``) or distance (metres, for ``speed``; experimental), then
+                enveloped across rides. The returned DataFrame then has an ``after``
+                column (one curve per value). Max 5 values; the date range is capped at
+                1 year when ``after`` is used.
 
         Returns:
-            pd.DataFrame: A pandas DataFrame containing the mean-max curve data.
+            pd.DataFrame: A pandas DataFrame containing the mean-max curve data, indexed
+                by the metric value. With ``after``, an ``after`` column distinguishes
+                the fatigue states.
 
         Raises:
             ValueError: If both ``sport`` and ``sports`` are provided, or neither is provided.
@@ -1510,12 +1524,14 @@ class Client(_OAuth2Mixin, _DelegationMixin, _TokenStorageMixin, _LocalCacheMixi
                 params["date"] = date
             if window_days is not None:
                 params["window_days"] = window_days
+        if after is not None:
+            params["after"] = [after] if isinstance(after, (int, float)) else after
 
         if self._cache_enabled():
             cache_key = self._generate_cache_key("mean_max", **params)
             cached = self._read_cache("mean_max", cache_key)
             if cached is not None:
-                return self._postprocess_dataframe(pd.read_parquet(BytesIO(cached)))
+                return self._shape_mean_max(pd.read_parquet(BytesIO(cached)), metric, after)
 
         with self._http_client() as client:
             response = client.get(
@@ -1527,8 +1543,16 @@ class Client(_OAuth2Mixin, _DelegationMixin, _TokenStorageMixin, _LocalCacheMixi
             if self._cache_enabled():
                 self._write_cache("mean_max", cache_key, response.content)
 
-            df = pd.read_parquet(BytesIO(response.content))
-            return self._postprocess_dataframe(df)
+            return self._shape_mean_max(pd.read_parquet(BytesIO(response.content)), metric, after)
+
+    def _shape_mean_max(self, df: pd.DataFrame, metric: str, after) -> pd.DataFrame:
+        """Standard post-processing for mean-max responses. The ``after`` response is
+        index-free on the wire; restore the metric-value index so its shape matches the
+        no-``after`` curve (with an extra ``after`` column)."""
+        df = self._postprocess_dataframe(df)
+        if after is not None:
+            df = df.set_index(metric)
+        return df
 
     def get_longitudinal_awd(
         self,
@@ -2380,7 +2404,9 @@ class Client(_OAuth2Mixin, _DelegationMixin, _TokenStorageMixin, _LocalCacheMixi
                 params={"only_root": only_root},
             )
             self._raise_for_status(response)
-            return [Sport(sport) for sport in response.json()]
+            # Sport.parse: the recommended OST way to ingest external input (tolerates sports newer
+            # than the bundled taxonomy).
+            return [Sport.parse(sport) for sport in response.json()]
 
     def get_tags(self) -> list[str]:
         """Gets a list of all tags used by the user.
@@ -2584,7 +2610,7 @@ class Client(_OAuth2Mixin, _DelegationMixin, _TokenStorageMixin, _LocalCacheMixi
 
             data = {}
             if sport is not None:
-                data["sport"] = sport.value if isinstance(sport, Enum) else sport
+                data["sport"] = self._enums_to_strings([sport])[0]
 
             with self._http_client() as client:
                 response = client.post(
@@ -2764,6 +2790,7 @@ __all__ = sorted([
     "DailyResponse",
     "Marker",
     "Metric",
+    "Modifier",
     "Scope",
     "Sport",
     "TeamResponse",

{sweatstack-0.80.0 → sweatstack-0.82.0}/src/sweatstack/openapi_schemas.py

@@ -985,54 +985,7 @@ class SpeedSummary(BaseModel):
     max: float | None = Field(None, title='Max')
 
 
-class Sport(Enum):
-    cycling = 'cycling'
-    cycling_road = 'cycling.road'
-    cycling_tt = 'cycling.tt'
-    cycling_cyclocross = 'cycling.cyclocross'
-    cycling_gravel = 'cycling.gravel'
-    cycling_mountainbike = 'cycling.mountainbike'
-    cycling_track = 'cycling.track'
-    cycling_track_250m = 'cycling.track.250m'
-    cycling_track_333m = 'cycling.track.333m'
-    cycling_trainer = 'cycling.trainer'
-    running = 'running'
-    running_road = 'running.road'
-    running_track = 'running.track'
-    running_track_200m = 'running.track.200m'
-    running_track_400m = 'running.track.400m'
-    running_trail = 'running.trail'
-    running_treadmill = 'running.treadmill'
-    walking = 'walking'
-    walking_hiking = 'walking.hiking'
-    cross_country_skiing = 'cross_country_skiing'
-    cross_country_skiing_classic = 'cross_country_skiing.classic'
-    cross_country_skiing_skate = 'cross_country_skiing.skate'
-    cross_country_skiing_backcountry = 'cross_country_skiing.backcountry'
-    cross_country_skiing_ergometer = 'cross_country_skiing.ergometer'
-    cross_country_skiing_roller_skiing = 'cross_country_skiing.roller_skiing'
-    cross_country_skiing_roller_skiing_classic = (
-        'cross_country_skiing.roller_skiing.classic'
-    )
-    cross_country_skiing_roller_skiing_skate = (
-        'cross_country_skiing.roller_skiing.skate'
-    )
-    rowing = 'rowing'
-    rowing_ergometer = 'rowing.ergometer'
-    rowing_indoor = 'rowing.indoor'
-    rowing_regatta = 'rowing.regatta'
-    rowing_fixed_seat = 'rowing.fixed-seat'
-    rowing_coastal = 'rowing.coastal'
-    swimming = 'swimming'
-    swimming_pool = 'swimming.pool'
-    swimming_pool_50m = 'swimming.pool.50m'
-    swimming_pool_25m = 'swimming.pool.25m'
-    swimming_pool_25y = 'swimming.pool.25y'
-    swimming_pool_33m = 'swimming.pool.33m'
-    swimming_open_water = 'swimming.open_water'
-    swimming_flume = 'swimming.flume'
-    generic = 'generic'
-    unknown = 'unknown'
+from open_sport_taxonomy.pydantic import SportField as Sport  # OST sport type (see schemas.py)
 
 
 class SubscriptionPlan(Enum):

sweatstack-0.82.0/src/sweatstack/schemas.py

@@ -0,0 +1,94 @@
+"""SweatStack data schemas.
+
+Re-exports the Pydantic response models from :mod:`openapi_schemas`, the public sport types from
+OpenSportTaxonomy (``Sport`` and ``Modifier``), and extends the ``Metric``, ``Scope`` and
+``DailyMeasure`` enums with convenience methods.
+
+Sport values follow OpenSportTaxonomy: construct a known sport with ``Sport("cycling.road")`` and parse
+external/API input with ``Sport.parse(value)``. See https://github.com/SweatStack/open-sport-taxonomy.
+
+Example:
+    from sweatstack import Sport
+    sport = Sport("cycling.road")
+    print(sport.label)                              # "road cycling"
+    print(sport.parent)                             # Sport("cycling")
+    print(sport.is_subsport_of(Sport("cycling")))   # True
+"""
+from open_sport_taxonomy import Modifier, Sport
+
+from .openapi_schemas import (
+    ActivityDetails, ActivitySummary, ApplicationMemberRole, AuthorizedTeamResponse,
+    BackfillStatus, DailyMeasure, DailyResponse,
+    Marker, Metric, Scope,
+    TeamResponse, TestDetails, TestResults, TestSummary, TokenResponse, TraceDetails,
+    TraceResolution, UserInfoResponse, UserResponse, UserSummary
+)
+
+
+def _metric_display_name(metric: Metric) -> str:
+    """Returns a human-readable display name for a metric.
+
+    This function converts a Metric enum value into a formatted string suitable for display.
+    """
+    return metric.value.replace("_", " ")
+
+
+@classmethod
+def _metric_missing(cls, value: str):
+    """Handle unknown metric values from newer API versions.
+
+    This allows the client to gracefully handle new metrics added to the API
+    without requiring a client library update. Unknown values become dynamic
+    enum members that behave like regular Metric values.
+    """
+    pseudo_member = object.__new__(cls)
+    pseudo_member._name_ = value
+    pseudo_member._value_ = value
+    cls._value2member_map_[value] = pseudo_member  # Cache for future lookups
+    return pseudo_member
+
+
+Metric._missing_ = _metric_missing
+Metric.display_name = _metric_display_name
+Metric.display_name.__doc__ = _metric_display_name.__doc__
+
+
+@classmethod
+def _scope_missing(cls, value: str):
+    """Handle unknown scope values from newer API versions."""
+    pseudo_member = object.__new__(cls)
+    pseudo_member._name_ = value
+    pseudo_member._value_ = value
+    cls._value2member_map_[value] = pseudo_member
+    return pseudo_member
+
+
+Scope._missing_ = _scope_missing
+
+
+def _daily_measure_display_name(measure: DailyMeasure) -> str:
+    """Returns a human-readable display name for a daily measure.
+
+    This function converts a DailyMeasure enum value into a formatted string suitable for display.
+    """
+    return measure.value.replace("_", " ")
+
+
+@classmethod
+def _daily_measure_missing(cls, value: str):
+    """Handle unknown daily measure values from newer API versions.
+
+    This allows the client to gracefully handle new measures added to the API
+    without requiring a client library update. Unknown values become dynamic
+    enum members that behave like regular DailyMeasure values.
+    """
+    pseudo_member = object.__new__(cls)
+    pseudo_member._name_ = value
+    pseudo_member._value_ = value
+    cls._value2member_map_[value] = pseudo_member  # Cache for future lookups
+    return pseudo_member
+
+
+DailyMeasure._missing_ = _daily_measure_missing
+DailyMeasure.display_name = _daily_measure_display_name
+DailyMeasure.display_name.__doc__ = _daily_measure_display_name.__doc__

{sweatstack-0.80.0 → sweatstack-0.82.0}/src/sweatstack/streamlit.py

@@ -466,7 +466,7 @@ class StreamlitAuth:
         selected_activity = st.selectbox(
             "Select an activity",
             activities,
-            format_func=lambda activity: f"{activity.start.date().isoformat()} {activity.sport.display_name()}",
+            format_func=lambda activity: f"{activity.start.date().isoformat()} {activity.sport.label}",
         )
         return selected_activity
 
@@ -479,33 +479,33 @@ class StreamlitAuth:
             only_root: If True, only returns root sports without parents. Defaults to False.
             allow_multiple: If True, allows selecting multiple sports. Defaults to False.
             only_available: If True, only shows sports available to the user. If False, shows all
-                sports defined in the Sport enum. Defaults to True.
+                standard OpenSportTaxonomy sports. Defaults to True.
 
         Returns:
             Sport or list[Sport]: The selected sport or list of sports, depending on allow_multiple.
 
         Note:
-            Sports are displayed in a human-readable format using the display_name function.
+            Sports are displayed in a human-readable format using each sport's ``label``.
         """
         if only_available:
             sports = self.client.get_sports(only_root)
         else:
             if only_root:
-                sports = [sport for sport in Sport if "." not in sport.value]
+                sports = [s for s in Sport.all() if "." not in s.code and not s.modifiers]
             else:
-                sports = Sport
+                sports = Sport.all()
 
         if allow_multiple:
             selected_sport = st.multiselect(
                 "Select sports",
                 sports,
-                format_func=lambda sport: sport.display_name(),
+                format_func=lambda sport: sport.label,
             )
         else:
             selected_sport = st.selectbox(
                 "Select a sport",
                 sports,
-                format_func=lambda sport: sport.display_name(),
+                format_func=lambda sport: sport.label,
             )
         return selected_sport
 

sweatstack-0.82.0/tests/test_longitudinal_mean_max_after.py

@@ -0,0 +1,80 @@
+"""Tests for the `after` (fatigue-state) param on get_longitudinal_mean_max."""
+
+from io import BytesIO
+from unittest.mock import MagicMock, patch
+
+import pandas as pd
+import pytest
+
+from sweatstack.client import Client
+
+
+@pytest.fixture
+def client():
+    c = Client.__new__(Client)
+    c.url = "https://test.sweatstack.no"
+    c._access_token = None
+    c.streamlit_compatible = False
+    c.skip_token_expiry_check = True
+    return c
+
+
+def _index_free_after_response() -> bytes:
+    """An index-free `after` long-format response, as the API returns it."""
+    df = pd.DataFrame({
+        "power": [100.0, 200.0, 90.0, 180.0],
+        "after": [0.0, 0.0, 500.0, 500.0],
+        "duration": pd.to_timedelta([300, 60, 200, 40], unit="s"),
+        "start": pd.to_datetime(["2024-01-01"] * 4, utc=True),
+        "activity_id": ["a", "a", "b", "b"],
+        "sport": ["cycling"] * 4,
+    })
+    buf = BytesIO()
+    df.to_parquet(buf, index=False)
+    return buf.getvalue()
+
+
+def _call(client, **kwargs):
+    response = MagicMock(status_code=200, content=_index_free_after_response())
+    http = MagicMock()
+    http.__enter__ = MagicMock(return_value=http)
+    http.__exit__ = MagicMock(return_value=False)
+    http.get.return_value = response
+    with patch.object(client, "_http_client", return_value=http), \
+         patch.object(client, "_raise_for_status"), \
+         patch.object(client, "_cache_enabled", return_value=False):
+        result = client.get_longitudinal_mean_max(sports=["cycling"], metric="power", **kwargs)
+    return result, http.get.call_args.kwargs["params"]
+
+
+def test_after_list_is_sent_and_shape_is_metric_indexed(client):
+    result, params = _call(client, after=[0, 500])
+    # repeated query param
+    assert params["after"] == [0, 500]
+    # shape parallels the no-after curve: metric value is the index, `after` a column
+    assert result.index.name == "power"
+    assert "after" in result.columns
+    assert set(result["after"].unique()) == {0.0, 500.0}
+    # postprocessed to standard dtypes
+    assert result["duration"].dtype == "timedelta64[ns]"
+
+
+def test_single_after_is_normalised_to_a_list(client):
+    _result, params = _call(client, after=500)
+    assert params["after"] == [500]
+
+
+def test_no_after_is_unchanged(client):
+    # without `after`, no after param is sent and the metric stays the index
+    response = MagicMock(status_code=200)
+    df = pd.DataFrame({"duration": pd.to_timedelta([60], unit="s")}, index=pd.Index([200.0], name="power"))
+    buf = BytesIO(); df.to_parquet(buf); response.content = buf.getvalue()
+    http = MagicMock()
+    http.__enter__ = MagicMock(return_value=http); http.__exit__ = MagicMock(return_value=False)
+    http.get.return_value = response
+    with patch.object(client, "_http_client", return_value=http), \
+         patch.object(client, "_raise_for_status"), \
+         patch.object(client, "_cache_enabled", return_value=False):
+        result = client.get_longitudinal_mean_max(sports=["cycling"], metric="power")
+    assert "after" not in http.get.call_args.kwargs["params"]
+    assert result.index.name == "power"

{sweatstack-0.80.0 → sweatstack-0.82.0}/tests/test_public_surface.py

@@ -62,6 +62,7 @@ class TestDunderAll:
             "Client",
             "TraceResolution",
             "Sport",
+            "Modifier",
             "SweatStackNotFoundError",
             "SweatStackAPIError",
             "enable_cache",