sweatstack 0.81.0__tar.gz → 0.83.0__tar.gz

{sweatstack-0.81.0 → sweatstack-0.83.0}/CHANGELOG.md

@@ -5,6 +5,22 @@ 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.83.0] - 2026-06-16
+
+### Added
+- Trace responses now include `test` and `test_match` (server-side test matching).
+
+### Fixed
+- Fixes Dailies response schema.
+
+
+## [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)

{sweatstack-0.81.0 → sweatstack-0.83.0}/PKG-INFO

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

{sweatstack-0.81.0 → sweatstack-0.83.0}/pyproject.toml

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

sweatstack-0.83.0/src/sweatstack/cli.py

@@ -0,0 +1,111 @@
+import ast
+import re
+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:
+    """Type every ``sport`` / ``sports`` model field as OpenSportTaxonomy's permissive ``SportField``.
+
+    The API exposes ``sport`` as a free-form OpenSportTaxonomy string, so datamodel-codegen types these
+    fields as plain ``str``. We retype them to ``SportField``, which validates an inbound string to an
+    ``open_sport_taxonomy.Sport`` and serialises back to the canonical wire string, tolerating sports
+    newer than the bundled taxonomy. Any leftover generated ``Sport`` schema is dropped. Anchored on the
+    AST (not a text match) and idempotent, so it survives regeneration.
+    """
+    src = path.read_text()
+    tree = ast.parse(src)
+    lines = src.splitlines(keepends=True)
+
+    drop: set[int] = set()        # 0-indexed lines to remove
+    replace: dict[int, str] = {}  # 0-indexed line -> new text
+
+    # Drop a leftover generated `Sport` schema (the server may still emit an unused one) ...
+    for node in tree.body:
+        if isinstance(node, ast.ClassDef) and node.name == "Sport":
+            drop.update(range(node.lineno - 1, node.end_lineno))
+    # ... and any SportField import from a previous run (re-injected cleanly below).
+    for i, line in enumerate(lines):
+        if line.startswith("from open_sport_taxonomy.pydantic import SportField"):
+            drop.add(i)
+
+    # Retype every `sport` / `sports` field annotation: str -> SportField (str | None, list[str], ...).
+    for node in ast.walk(tree):
+        if (isinstance(node, ast.AnnAssign) and isinstance(node.target, ast.Name)
+                and node.target.id in ("sport", "sports")):
+            annotation = ast.get_source_segment(src, node.annotation)
+            retyped = re.sub(r"\bstr\b", "SportField", annotation)
+            if retyped != annotation:
+                i = node.lineno - 1
+                replace[i] = lines[i].replace(annotation, retyped, 1)
+
+    out: list[str] = []
+    for i, line in enumerate(lines):
+        if i in drop:
+            continue
+        out.append(replace.get(i, line))
+        if line.startswith("from __future__ import annotations"):
+            out.append("from open_sport_taxonomy.pydantic import SportField  # OST sport type (see schemas.py)\n")
+    path.write_text("".join(out))
+
+
+def _restore_naive_local_datetimes(path: Path) -> None:
+    """Type local timestamps as ``NaiveDatetime`` rather than ``AwareDatetime``.
+
+    The API returns *local* timestamps without a timezone, but datamodel-codegen types every
+    ``date-time`` field as ``AwareDatetime`` -- which rejects a naive value. Retype the local fields
+    (those whose name ends in ``_local``) back to ``NaiveDatetime``, and keep ``registered_at``
+    accepting either. AST-anchored and idempotent, so it survives regeneration (and replaces the
+    manual fixups this file has needed in the past).
+    """
+    src = path.read_text()
+    tree = ast.parse(src)
+    lines = src.splitlines(keepends=True)
+    replace: dict[int, str] = {}
+
+    for node in ast.walk(tree):
+        if not (isinstance(node, ast.AnnAssign) and isinstance(node.target, ast.Name)):
+            continue
+        name = node.target.id
+        annotation = ast.get_source_segment(src, node.annotation)
+        if name.endswith("_local") and "AwareDatetime" in annotation:
+            retyped = annotation.replace("AwareDatetime", "NaiveDatetime")
+        elif name == "registered_at" and annotation == "AwareDatetime":
+            retyped = "AwareDatetime | NaiveDatetime"
+        else:
+            continue
+        i = node.lineno - 1
+        replace[i] = lines[i].replace(annotation, retyped, 1)
+
+    if not replace:
+        return  # already naive (idempotent re-run)
+
+    src = "".join(replace.get(i, line) for i, line in enumerate(lines))
+    if "    NaiveDatetime,\n" not in src:  # ensure the import exists
+        src = src.replace("    AwareDatetime,\n", "    AwareDatetime,\n    NaiveDatetime,\n", 1)
+    path.write_text(src)
+
+
+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)
+    _restore_naive_local_datetimes(output)
+
+    model = output.read_text()
+    print(model)

{sweatstack-0.81.0 → sweatstack-0.83.0}/src/sweatstack/client.py

@@ -1464,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.
 
@@ -1475,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.
@@ -1515,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(
@@ -1532,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,
@@ -2162,7 +2181,7 @@ class Client(_OAuth2Mixin, _DelegationMixin, _TokenStorageMixin, _LocalCacheMixi
             dailies = [DailyResponse.model_validate(item) for item in response.json()]
         if as_dataframe:
             if not dailies:
-                df = pd.DataFrame(columns=["date", "value", "source"])
+                df = pd.DataFrame(columns=["date", "value", "status", "source"])
                 df = df.set_index("date")
             else:
                 df = pd.DataFrame([d.model_dump() for d in dailies])