sweatstack 0.82.0__tar.gz → 0.84.0__tar.gz

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

@@ -5,6 +5,27 @@ 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.84.0] - 2026-06-17
+
+### Added
+
+- `get_longitudinal_mean_max(by=...)`: pass `by="duration"` (with `after`, for `power`) to get the fatigue curve indexed by duration instead of by intensity. Default `by="intensity"` is unchanged.
+
+### Changed
+
+- Require `pyarrow>=20`: pyarrow 18/19 fail to read the server's parquet ("Repetition level histogram size mismatch") for longitudinal and adaptive-sampling responses; pyarrow 20+ reads them correctly.
+
+
+## [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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sweatstack
-Version: 0.82.0
+Version: 0.84.0
 Summary: The official Python client for SweatStack
 Project-URL: Homepage, https://sweatstack.no
 Project-URL: Documentation, https://docs.sweatstack.no/getting-started/
@@ -26,7 +26,7 @@ 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
+Requires-Dist: pyarrow>=20.0.0
 Requires-Dist: pydantic>=2.10.5
 Provides-Extra: fastapi
 Requires-Dist: cryptography>=41.0.0; extra == 'fastapi'

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

@@ -1,6 +1,6 @@
 [project]
 name = "sweatstack"
-version = "0.82.0"
+version = "0.84.0"
 description = "The official Python client for SweatStack"
 readme = "README.md"
 license = "MIT"
@@ -26,7 +26,9 @@ dependencies = [
     "open-sport-taxonomy[pydantic]>=0.10.0",
     "pandas>=2.2.3",
     "platformdirs>=4.0.0",
-    "pyarrow>=18.0.0",
+    # >=20: 18/19 raise "Repetition level histogram size mismatch" reading the server's
+    # polars-written parquet (size-statistics histograms); fixed in pyarrow 20.
+    "pyarrow>=20.0.0",
     "pydantic>=2.10.5",
 ]
 

sweatstack-0.84.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.82.0 → sweatstack-0.84.0}/src/sweatstack/client.py

@@ -1465,6 +1465,7 @@ class Client(_OAuth2Mixin, _DelegationMixin, _TokenStorageMixin, _LocalCacheMixi
         date: date | str | None = None,
         window_days: int | None = None,
         after: list[float] | float | None = None,
+        by: Literal["intensity", "duration"] = "intensity",
     ) -> pd.DataFrame:
         """Gets the mean-max curve for one or more sports and a metric.
 
@@ -1482,11 +1483,14 @@ class Client(_OAuth2Mixin, _DelegationMixin, _TokenStorageMixin, _LocalCacheMixi
                 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.
+            by: Axis to index the curve on. ``"intensity"`` (default) indexes by the metric
+                value (unchanged). ``"duration"`` indexes by duration via the fast segment
+                kernel; currently requires ``after`` and ``metric="power"``.
 
         Returns:
-            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.
+            pd.DataFrame: A pandas DataFrame containing the mean-max curve data, indexed by
+                the metric value (``by="intensity"``) or by duration (``by="duration"``).
+                With ``after``, an ``after`` column distinguishes the fatigue states.
 
         Raises:
             ValueError: If both ``sport`` and ``sports`` are provided, or neither is provided.
@@ -1508,6 +1512,7 @@ class Client(_OAuth2Mixin, _DelegationMixin, _TokenStorageMixin, _LocalCacheMixi
         params = {
             "sport": self._enums_to_strings(sports),
             "metric": metric,
+            "by": by,
         }
         if start is not None:
             params["start"] = start
@@ -1531,7 +1536,7 @@ class Client(_OAuth2Mixin, _DelegationMixin, _TokenStorageMixin, _LocalCacheMixi
             cache_key = self._generate_cache_key("mean_max", **params)
             cached = self._read_cache("mean_max", cache_key)
             if cached is not None:
-                return self._shape_mean_max(pd.read_parquet(BytesIO(cached)), metric, after)
+                return self._shape_mean_max(pd.read_parquet(BytesIO(cached)), metric, after, by)
 
         with self._http_client() as client:
             response = client.get(
@@ -1543,15 +1548,16 @@ class Client(_OAuth2Mixin, _DelegationMixin, _TokenStorageMixin, _LocalCacheMixi
             if self._cache_enabled():
                 self._write_cache("mean_max", cache_key, response.content)
 
-            return self._shape_mean_max(pd.read_parquet(BytesIO(response.content)), metric, after)
+            return self._shape_mean_max(pd.read_parquet(BytesIO(response.content)), metric, after, by)
 
-    def _shape_mean_max(self, df: pd.DataFrame, metric: str, after) -> pd.DataFrame:
+    def _shape_mean_max(self, df: pd.DataFrame, metric: str, after, by: str = "intensity") -> 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)."""
+        index-free on the wire; restore the natural index so its shape matches the
+        no-``after`` curve (with an extra ``after`` column): the metric value for
+        ``by="intensity"``, or ``duration`` for ``by="duration"``."""
         df = self._postprocess_dataframe(df)
         if after is not None:
-            df = df.set_index(metric)
+            df = df.set_index("duration" if by == "duration" else metric)
         return df
 
     def get_longitudinal_awd(
@@ -2181,7 +2187,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])