PyPI - sweatstack - Versions diffs - 0.11.1__py3-none-any.whl → 0.13.0__py3-none-any.whl - Mend

sweatstack 0.11.1py3-none-any.whl → 0.13.0py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (17) hide show

sweatstack/cli.py +2 -2
sweatstack/client.py +460 -440
sweatstack/constants.py +1 -0
sweatstack/jupyterlab_oauth2_startup.py +5 -0
sweatstack/openapi_schemas.py +368 -0
sweatstack/py.typed +0 -0
sweatstack/schemas.py +3 -229
sweatstack/streamlit.py +116 -0
sweatstack/utils.py +13 -0
sweatstack-0.13.0.dist-info/METADATA +117 -0
sweatstack-0.13.0.dist-info/RECORD +16 -0
{sweatstack-0.11.1.dist-info → sweatstack-0.13.0.dist-info}/WHEEL +1 -1
sweatstack/Sweat Stack examples/Getting started.ipynb +0 -28784
sweatstack/plotting.py +0 -251
sweatstack-0.11.1.dist-info/METADATA +0 -359
sweatstack-0.11.1.dist-info/RECORD +0 -13
{sweatstack-0.11.1.dist-info → sweatstack-0.13.0.dist-info}/entry_points.txt +0 -0

sweatstack/client.py CHANGED Viewed

@@ -1,136 +1,35 @@
 import base64
+import contextlib
+import random
 import hashlib
 import os
-import random
 import secrets
+import time
 import urllib
 import webbrowser
-from http.server import HTTPServer, BaseHTTPRequestHandler
-from io import BytesIO, IOBase, StringIO
-from contextlib import contextmanager
-from datetime import date, datetime, timedelta, timezone
-from pathlib import Path
-from typing import Dict, Iterator, List,Union
-from urllib.parse import parse_qs, urljoin, urlparse
+from datetime import date, datetime
+from functools import wraps
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from io import BytesIO
+from typing import Any, Generator, get_type_hints, List, Literal
+from urllib.parse import parse_qs, urlparse
+import httpx
 import pandas as pd
-try:
-    import pyarrow
-except ImportError:
-    pyarrow = None
-import requests
-from .schemas import ActivityDetail, ActivitySummary, Metric, PermissionType, Sport, User
-try:
-    from .plotting import PlottingMixin
-except ImportError as e:
-    PlottingMixin = object
-AUTH_SUCCESSFUL_RESPONSE = """
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Authorization Successful</title>
-    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/tachyons/4.11.1/tachyons.min.css">
-</head>
-<body class="bg-light-gray vh-100 flex items-center justify-center">
-    <article class="mw6 center bg-white br3 pa3 pa4-ns mv3 ba b--black-10">
-        <div class="tc">
-            <div class="flex justify-center items-center">
-                <img src="https://sweatstack.no/images/favicon-white-bg-small.png" alt="Sweat Stack Logo" class="h4 w4 dib pa2 ml2">
-                <div class="f1 b black ph3">❤️</div>
-                <img src="https://s3.dualstack.us-east-2.amazonaws.com/pythondotorg-assets/media/community/logos/python-logo-only.png" alt="Python Logo" class="h4 w4 dib pa2 ml2">
-            </div>
-            <h1 class="f2 mb2">Sweat Stack Python login successful</h1>
-        </div>
-        <p class="lh-copy measure center f4 black-70">
-            You can now close this window and return to your Python code.
-        </p>
-    </article>
-    <script>
-        setTimeout(function() {
-            window.close();
-        }, 5000);
-    </script>
-</body>
-</html>
-"""
-SWEAT_STACK_CLIENT_ID = "j0mX9SQQAJXHmf6jUsbX"
-if "SWEAT_STACK_URL" not in os.environ:
-    os.environ["SWEAT_STACK_URL"] = "https://app.sweatstack.no"
-class ProgressBar:
-    def __init__(self, description, total, bar_length=20):
-        self.description = description
-        self.total = total
-        self.bar_length = bar_length
-        self.current = 0
-    def __enter__(self):
-        return self
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self.show_progress(self.total)
-        print()  # Print a newline at the end
-    def show_progress(self, current):
-        self.current = current
-        progress = self.current / self.total
-        filled_length = int(self.bar_length * progress)
-        bar = '#' * filled_length + "-" * (self.bar_length - filled_length)
-        print(f"\r{self.description}: [{bar}] {progress:.0%} ({current}/{self.total})", end="", flush=True)
-class Session(requests.Session):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-    def _get_url(self):
-        """
-        This method enables easy switching between Sweat Stack instances after module import.
-        """
-        return os.environ.get("SWEAT_STACK_URL")
-    def request(self, method, url, *args, **kwargs):
-        url = urljoin(self._get_url(), url)
-        return super().request(method, url, *args, **kwargs)
+from .schemas import ActivityDetails, ActivitySummary, Sport, TraceDetails
+from .utils import decode_jwt_body
-class SweatStack(PlottingMixin):
-    def __init__(self, jwt: str = None):
-        self.jwt = jwt
-        self.root_jwt = self.jwt
+AUTH_SUCCESSFUL_RESPONSE = "<!DOCTYPE html><html><body><h1>Authentication successful. You can now close this window.</h1></body></html>"
+OAUTH2_CLIENT_ID = "5382f68b0d254378"
-    @property
-    def jwt(self):
-        if self._jwt is not None:
-            return self._jwt
-        else:
-            return os.environ.get("SWEAT_STACK_API_KEY")
-    @jwt.setter
-    def jwt(self, value):
-        self._jwt = value
-    def _get_url(self):
-        """
-        This method enables easy switching between Sweat Stack instances after module import.
-        """
-        return os.environ.get("SWEAT_STACK_URL")
+class OAuth2Mixin:
     def login(self):
         class AuthHandler(BaseHTTPRequestHandler):
             def log_message(self, format, *args):
-                # Override to disable logging
+                # This override disables logging.
                 pass
             def do_GET(self):
@@ -158,11 +57,12 @@ class SweatStack(PlottingMixin):
         redirect_uri = f"http://localhost:{port}"
         params = {
-            "client_id": SWEAT_STACK_CLIENT_ID,
+            "client_id": OAUTH2_CLIENT_ID,
             "redirect_uri": redirect_uri,
             "code_challenge": code_challenge,
+            "scope": "data:read",
         }
-        base_url = self._get_url()
+        base_url = self.url
         path = "/oauth/authorize"
         authorization_url = urllib.parse.urljoin(base_url, path + "?" + urllib.parse.urlencode(params))
         webbrowser.open(authorization_url)
@@ -175,403 +75,523 @@ class SweatStack(PlottingMixin):
         try:
             server.handle_request()
         except TimeoutError:
-            raise Exception("Sweat Stack Python login timed out after 30 seconds. Please try again.")
+            raise Exception("SweatStack Python login timed out after 30 seconds. Please try again.")
         if hasattr(server, "code"):
             token_data = {
                 "grant_type": "authorization_code",
-                "client_id": SWEAT_STACK_CLIENT_ID,
+                "client_id": OAUTH2_CLIENT_ID,
                 "code": server.code,
                 "code_verifier": code_verifier
             }
-            response = requests.post(
-                f"{self._get_url()}/oauth/token",
+            response = httpx.post(
+                f"{self.url}/oauth/token",
                 data=token_data,
             )
-            response.raise_for_status()
+            try:
+                response.raise_for_status()
+            except httpx.HTTPStatusError as e:
+                raise Exception(f"SweatStack Python login failed. Please try again.") from e
             token_response = response.json()
             self.jwt = token_response.get("access_token")
-            os.environ["SWEAT_STACK_API_KEY"] = self.jwt  # This env variable is for example used by the JupyterLab extension.
-            print(f"Sweat Stack Python login successful.")
+            self.api_key = self.jwt
+            self.refresh_token = token_response.get("refresh_token")
+            print(f"SweatStack Python login successful.")
         else:
-            raise Exception("Sweat Stack Python login failed. Please try again.")
-    @contextmanager
-    def _http_client(self):
-        headers = {
-            "authorization": f"Bearer {self.jwt}"
-        }
-        with Session() as session:
-            session.headers.update(headers)
-            session.base_url = self._get_url()
-            yield session
-    def list_users(self, permission_type: Union[PermissionType, str] = None) -> List[User]:
-        if permission_type is not None:
-            params = {"type": permission_type.value if isinstance(permission_type, PermissionType) else permission_type}
-        else:
-            params = {}
+            raise Exception("SweatStack Python login failed. Please try again.")
-        with self._http_client() as client:
-            response = client.get("/api/users/", params=params)
-            response.raise_for_status()
-            users = response.json()
-        return [User.model_validate(user) for user in users]
-    def list_accessible_users(self) -> List[User]:
-        return self.list_users(permission_type=PermissionType.received)
-    def whoami(self) -> User:
+class Client(OAuth2Mixin):
+    def __init__(
+        self,
+        api_key: str | None = None,
+        refresh_token: str | None = None,
+        url: str | None = None,
+    ):
+        self.api_key = api_key
+        self.refresh_token = refresh_token
+        self.url = url
+    def _do_token_refresh(self, tz_offset: int) -> str:
         with self._http_client() as client:
-            response = client.get("/api/users/me")
+            response = client.post(
+                "/api/v1/oauth/token",
+                json={
+                    "grant_type": "refresh_token",
+                    "refresh_token": self.refresh_token,
+                    "tz_offset": tz_offset,
+                },
+            )
             response.raise_for_status()
-            return User.model_validate(response.json())
+            return response.json()["access_token"]
+    def _check_token_expiry(self, token: str) -> str:
+        try:
+            body = decode_jwt_body(token)
+            # Margin in seconds to account for time to token validation of the next request
+            TOKEN_EXPIRY_MARGIN = 5
+            if body["exp"] - TOKEN_EXPIRY_MARGIN < time.time():
+                # Token is (almost) expired, refresh it
+                token = self._do_token_refresh(body["tz_offset"])
+                self._api_key = token
+        except Exception:
+            # If token can't be decoded, just return as-is
+            # @TODO: This probably should be handled differently
+            pass
+        return token
+    @property
+    def api_key(self) -> str:
+        if self._api_key is not None:
+            value = self._api_key
+        else:
+            value = os.getenv("SWEATSTACK_API_KEY")
+        if value is None:
+            # A non-authenticated client is a potentially valid use-case.
+            return None
+        return self._check_token_expiry(value)
+    @api_key.setter
+    def api_key(self, value: str):
+        self._api_key = value
-    def get_delegated_token(self, user: Union[User, str]):
-        if isinstance(user, str):
-            user_id = user
+    @property
+    def refresh_token(self) -> str:
+        if self._refresh_token is not None:
+            return self._refresh_token
         else:
-            user_id = user.id
+            return os.getenv("SWEATSTACK_REFRESH_TOKEN")
-        with self._http_client() as client:
-            response = client.get(
-                f"/api/users/{user_id}/delegated-token",
-            )
-            response.raise_for_status()
-            return response.json()["jwt"]
+    @refresh_token.setter
+    def refresh_token(self, value: str):
+        self._refresh_token = value
+    @property
+    def url(self) -> str:
+        """
+        This determines which SweatStack URL to use, allowing the use of a non-default instance.
+        This is useful for example during local development.
+        Please note that changing the url probably requires changing the `OAUTH2_CLIENT_ID` as well.
+        """
+        if self._url is not None:
+            return self._url
+        if env_url := os.getenv("SWEATSTACK_URL"):
+            return env_url
+        return DEFAULT_URL
-    def switch_user(self, user: Union[User, str]):
-        self.root_jwt = self.jwt
-        self.jwt = self.get_delegated_token(user)
+    @url.setter
+    def url(self, value: str):
+        self._url = value
-    def switch_to_root_user(self):
+    @contextlib.contextmanager
+    def _http_client(self):
         """
-        Switch back to the root user by setting the JWT to the root JWT.
+        Creates an httpx client with the base URL and authentication headers pre-configured.
         """
-        self.jwt = self.root_jwt
-    def _check_timezone_aware(self, date_obj: Union[date, datetime]):
-        if not isinstance(date_obj, date) and date_obj.tzinfo is None and date_obj.tzinfo.utcoffset(date_obj) is None:
-            return date_obj.replace(tzinfo=timezone.utc)
-        else:
-            return date_obj
-    def _fetch_activities(
-            self,
-            sport: Union[Sport, str] = None,
-            start: Union[date, datetime] = None,
-            end: Union[date, datetime] = None,
-            limit: int = None,
-            as_pydantic: bool = False,
-        ) -> Iterator[Union[Dict, ActivitySummary]]:
-        if limit is None:
-            limit = 1000
-        activities_count = 0
-        params = {}
-        if sport is not None:
-            if isinstance(sport, Sport):
-                sport = sport.value
-            params["sport"] = sport
+        headers = {}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+        with httpx.Client(base_url=self.url, headers=headers) as client:
+            yield client
+    def _get_activities_generator(
+        self,
+        *,
+        start: date | None = None,
+        end: date | None = None,
+        sports: list[Sport | str] | None = None,
+        tags: list[str] | None = None,
+        limit: int = 100,
+    ) -> Generator[ActivitySummary, None, None]:
+        num_returned = 0
+        default_limit = 100
+        params = {
+            "limit": default_limit,
+            "offset": 0,
+        }
         if start is not None:
-            params["start"] = self._check_timezone_aware(start).isoformat()
+            params["start"] = start.isoformat()
         if end is not None:
-            params["end"] = self._check_timezone_aware(end).isoformat()
+            params["end"] = end.isoformat()
+        if sports is not None:
+            params["sports"] = sports
+        if tags is not None:
+            params["tags"] = tags
         with self._http_client() as client:
-            step_size = limit
-            offset = 0
             while True:
-                params["limit"] = step_size
-                params["offset"] = offset
-                response = client.get("/api/activities/", params=params)
+                response = client.get(
+                    url="/api/v1/activities/",
+                    params=params,
+                )
                 response.raise_for_status()
                 activities = response.json()
                 for activity in activities:
-                    activities_count += 1
-                    if limit is not None and activities_count > limit:
-                        break
-                    yield ActivitySummary.model_validate(activity) if as_pydantic else activity
-                if limit is not None and activities_count > limit or len(activities) < step_size:
-                    break
+                    yield ActivitySummary.model_validate(activity)
-                offset += step_size
+                    num_returned += 1
+                    if num_returned >= limit:
+                        return
+                if len(activities) < default_limit:
+                    return
+                params["limit"] = min(default_limit, limit - num_returned)
+                params["offset"] += default_limit
-    def list_activities(self, sport: Union[Sport, str] = None, start: Union[date, datetime] = None, end: Union[date, datetime] = None, limit: int = None, as_dataframe: bool = True) -> Union[Iterator[Dict], pd.DataFrame]:
+    def get_activities(
+        self,
+        *,
+        start: date | None = None,
+        end: date | None = None,
+        sports: list[Sport | str] | None = None,
+        tags: list[str] | None = None,
+        limit: int = 100,
+        as_dataframe: bool = False,
+    ) -> Generator[ActivitySummary, None, None] | pd.DataFrame:
+        generator = self._get_activities_generator(
+            start=start,
+            end=end,
+            sports=sports,
+            tags=tags,
+            limit=limit,
+        )
         if as_dataframe:
-            return pd.DataFrame(
-                self._fetch_activities(
-                    sport=sport,
-                    start=start,
-                    end=end,
-                    limit=limit,
-                    as_pydantic=False,
-                )
-            )
+            return pd.DataFrame([activity.model_dump() for activity in generator])
         else:
-            return self._fetch_activities(
-                sport=sport,
-                start=start,
-                end=end,
-                limit=limit,
-                as_pydantic=True,
-            )
-    def get_longitudinal_data(
-            self,
-            sport: Union[Sport, str],
-            metrics: List[Union[Metric, str]],
-            start: Union[date, datetime] = None,
-            end: Union[date, datetime] = None,
-        ) -> pd.DataFrame:
-        params = {}
-        if sport is not None:
-            if isinstance(sport, Sport):
-                sport = sport.value
-            params["sport"] = sport
+            return generator
-        if metrics is not None:
-            new_metrics = []
-            for metric in metrics:
-                if isinstance(metric, Metric):
-                    new_metrics.append(metric.value)
-                else:
-                    new_metrics.append(metric)
-            params["metrics"] = new_metrics
-        if start is not None:
-            params["start"] = self._check_timezone_aware(start).isoformat()
-        else:
-            params["start"] = (date.today() - timedelta(days=30)).isoformat()
-        if end is not None:
-            params["end"] = self._check_timezone_aware(end).isoformat()
-        try:
-            import pyarrow
-        except ImportError:
-            params["response_format"] = "csv"
-        else:
-            params["response_format"] = "parquet"
-        with self._http_client() as client:
-            response = client.get(f"/api/activities/data", params=params)
-            response.raise_for_status()
-            buffer = BytesIO(response.content)
-        if params["response_format"] == "parquet":
-            data = pd.read_parquet(buffer, engine="pyarrow")
-        else:
-            data = pd.read_csv(buffer)
-            data.index = pd.to_datetime(data.index)
-            data["duration"] = pd.to_timedelta(data["duration"])
-        return data
-    def get_activity(self, activity_id: str) -> ActivityDetail:
+    def get_latest_activity(
+        self,
+        *,
+        start: date | None = None,
+        end: date | None = None,
+        sport: Sport | None = None,
+        tag: str | None = None,
+    ) -> ActivityDetails:
+        return next(self.get_activities(
+            start=start,
+            end=end,
+            sports=[sport] if sport is not None else None,
+            tags=[tag] if tag is not None else None,
+            limit=1,
+        ))
+    def get_activity(self, activity_id: str) -> ActivityDetails:
         with self._http_client() as client:
-            response = client.get(f"/api/activities/{activity_id}")
+            response = client.get(url=f"/api/v1/activities/{activity_id}")
             response.raise_for_status()
-            return ActivityDetail(**response.json())
+            return ActivityDetails.model_validate(response.json())
-    def get_latest_activity(self) -> ActivityDetail:
-        activity = next(self._fetch_activities(limit=1, as_pydantic=True))
-        return self.get_activity(activity.id)
-    def get_activity_data(self, activity_id: str, fusion: bool = None) -> pd.DataFrame:
+    def get_activity_data(
+        self,
+        activity_id: str,
+        adaptive_sampling_on: Literal["power", "speed"] | None = None,
+    ) -> pd.DataFrame:
         params = {}
-        if fusion is not None:
-            params["fusion"] = fusion
+        if adaptive_sampling_on is not None:
+            params["adaptive_sampling_on"] = adaptive_sampling_on
         with self._http_client() as client:
             response = client.get(
-                f"/api/activities/{activity_id}/data",
+                url=f"/api/v1/activities/{activity_id}/data",
                 params=params,
             )
-            response.raise_for_status()
+        response.raise_for_status()
-        response = response.json()
-        data = pd.read_json(StringIO(response["data"]), orient="split")
-        data.index = pd.to_datetime(data.index)
-        data["duration"] = pd.to_timedelta(data["duration"], unit="ms")
+        return pd.read_parquet(BytesIO(response.content))
-        data.attrs["activity"] = None
-        data.attrs["column_mapping"] = None
-        data.attrs["activity"] = ActivityDetail.model_validate(response["activity"])
-        data.attrs["column_mapping"] = response["column_mapping"]
+    def get_activity_mean_max(
+        self,
+        activity_id: str,
+        metric: str,
+        adaptive_sampling: bool = False,
+    ) -> pd.DataFrame:
+        with self._http_client() as client:
+            response = client.get(
+                url=f"/api/v1/activities/{activity_id}/mean-max",
+                params={
+                    "metric": metric,
+                    "adaptive_sampling": adaptive_sampling,
+                },
+            )
+            response.raise_for_status()
+            return pd.read_parquet(BytesIO(response.content))
-        return data
-    def get_latest_activity_data(self, fusion: bool = None) -> pd.DataFrame:
-        activity = self.get_latest_activity()
-        return self.get_activity_data(activity.id, fusion=fusion)
+    def get_latest_activity_data(
+        self,
+        sport: Sport | None = None,
+        adaptive_sampling_on: Literal["power", "speed"] | None = None,
+    ) -> pd.DataFrame:
+        activity = self.get_latest_activity(sport=sport)
+        return self.get_activity_data(activity.id, adaptive_sampling_on)
-    def get_accumulated_work_duration(self, start: date, sport: Union[Sport, str], metric: Union[Metric, str], end: date=None) -> pd.DataFrame:
-        if not isinstance(start, date):
-            start = date.fromisoformat(start)
+    def get_latest_activity_mean_max(
+        self,
+        metric: str,
+        sport: Sport | None = None,
+        adaptive_sampling: bool = False,
+    ) -> pd.DataFrame:
+        activity = self.get_latest_activity(sport=sport)
+        return self.get_activity_mean_max(activity.id, metric, adaptive_sampling)
-        if end is None:
-            end = date.today()
-        if not isinstance(end, date):
-            end = date.fromisoformat(end)
+    def get_longitudinal_data(
+        self,
+        *,
+        sport: Sport | None = None,
+        sports: list[Sport | str] | None = None,
+        start: date | str,
+        end: date | str | None = None,
+        metrics: list[str] | None = None,
+        adaptive_sampling_on: Literal["power", "speed"] | None = None,
+    ) -> pd.DataFrame:
+        if sport and sports:
+            raise ValueError("Cannot specify both sport and sports")
+        if sport is not None:
+            sports = [sport]
+        elif sports is None:
+            sports = []
-        if not isinstance(metric, Metric):
-            metric = Metric(metric)
-        if not isinstance(sport, Sport):
-            sport = Sport(sport)
+        params = {
+            "sports": sports,
+            "start": start,
+        }
+        if end is not None:
+            params["end"] = end
+        if metrics is not None:
+            params["metrics"] = metrics
+        if adaptive_sampling_on is not None:
+            params["adaptive_sampling_on"] = adaptive_sampling_on
         with self._http_client() as client:
             response = client.get(
-                "/api/activities/accumulated-work-duration",
-                params={
-                    "start": start.strftime("%Y-%m-%dT%H:%M:%SZ"),
-                    "end": end.strftime("%Y-%m-%dT%H:%M:%SZ"),
-                    "sport": sport.value,
-                    "metric": metric.value,
-                }
+                url="/api/v1/activities/longitudinal-data",
+                params=params,
             )
             response.raise_for_status()
-            awd = pd.read_json(
-                StringIO(response.json()),
-                orient="split",
-                date_unit="s",
-                typ="series",
-            )
-            awd = pd.to_timedelta(awd, unit="seconds")
-            awd.name = "duration"
-            awd.index.name = metric.value
-            return awd
+        return pd.read_parquet(BytesIO(response.content))
-    def get_mean_max(
+    def get_longitudinal_mean_max(
         self,
         *,
-        sport: Union[Sport, str],
-        metric: Union[Metric, str],
-        start: Union[date, str] = None,
-        end: Union[date, str] = None,
+        sport: Sport | str,
+        metric: str,
+        date: date | str | None = None,
+        window_days: int | None = None,
     ) -> pd.DataFrame:
-        if start is None:
-            start = date.today() - timedelta(days=30)
-        elif not isinstance(start, date):
-            start = date.fromisoformat(start)
-        if end is None:
-            end = date.today()
-        elif not isinstance(end, date):
-            end = date.fromisoformat(end)
-        if not isinstance(metric, Metric):
-            metric = Metric(metric)
-        if not isinstance(sport, Sport):
-            sport = Sport(sport)
+        params = {
+            "sport": sport,
+            "metric": metric,
+        }
+        if date is not None:
+            params["date"] = date
+        if window_days is not None:
+            params["window_days"] = window_days
         with self._http_client() as client:
             response = client.get(
-                "/api/activities/mean-max",
-                params={
-                    "start": start.strftime("%Y-%m-%dT%H:%M:%SZ"),
-                    "end": end.strftime("%Y-%m-%dT%H:%M:%SZ"),
-                    "sport": sport.value,
-                    "metric": metric.value,
-                }
+                url="/api/v1/activities/longitudinal-mean-max",
+                params=params,
             )
             response.raise_for_status()
-            mean_max = pd.read_json(
-                StringIO(response.json()),
-                orient="split",
-                date_unit="s",
-                typ="series",
-            )
-            mean_max = pd.to_timedelta(mean_max, unit="seconds")
-            mean_max.name = "duration"
-            mean_max.index.name = metric.value
-            return mean_max
+        return pd.read_parquet(BytesIO(response.content))
+    def _get_traces_generator(
+        self,
+        *,
+        start: date | None = None,
+        end: date | None = None,
+        sports: list[Sport | str] | None = None,
+        tags: list[str] | None = None,
+        limit: int = 100,
+    ) -> Generator[TraceDetails, None, None]:
+        num_returned = 0
+        default_limit = 100
+        params = {
+            "limit": default_limit,
+            "offset": 0,
+        }
+        if start is not None:
+            params["start"] = start.isoformat()
+        if end is not None:
+            params["end"] = end.isoformat()
+        if sports is not None:
+            params["sports"] = sports
+        if tags is not None:
+            params["tags"] = tags
-    def _upload_activity(self, files):
+        with self._http_client() as client:
+            while True:
+                response = client.get(
+                    url="/api/v1/traces/",
+                    params=params,
+                )
+                response.raise_for_status()
+                traces = response.json()
+                for trace in traces:
+                    yield TraceDetails.model_validate(trace)
+                    num_returned += 1
+                    if num_returned >= limit:
+                        return
+                if len(traces) < default_limit:
+                    return
+                params["limit"] = min(default_limit, limit - num_returned)
+                params["offset"] += default_limit
+    def _normalize_dataframe_column(self, df: pd.DataFrame, column: str) -> pd.DataFrame:
+        normalized = pd.json_normalize(
+            df[column],
+        )
+        normalized = normalized.add_prefix(f"{column}.")
+        if column == "activity":
+            normalized = normalized.drop(["activity.traces", "activity.laps"], axis=1, errors="ignore")
+        return pd.concat([df.drop(column, axis=1), normalized], axis=1)
+    def get_traces(
+        self,
+        *,
+        start: date | None = None,
+        end: date | None = None,
+        sports: list[Sport | str] | None = None,
+        tags: list[str] | None = None,
+        limit: int = 100,
+        as_dataframe: bool = False,
+    ) -> Generator[TraceDetails, None, None] | pd.DataFrame:
+        generator = self._get_traces_generator(
+            start=start,
+            end=end,
+            sports=sports,
+            tags=tags,
+            limit=limit,
+        )
+        if not as_dataframe:
+            return generator
+        data = pd.DataFrame([trace.model_dump() for trace in generator])
+        if "activity" in data.columns:
+            data = self._normalize_dataframe_column(data, "activity")
+        if "lap" in data.columns:
+            data = self._normalize_dataframe_column(data, "lap")
+        return data
+    def create_trace(
+        self,
+        *,
+        timestamp: datetime,
+        lactate: float | None = None,
+        rpe: int | None = None,
+        notes: str | None = None,
+        power: int | None = None,
+        speed: float | None = None,
+        heart_rate: int | None = None,
+        tags: list[str] | None = None,
+    ) -> TraceDetails:
         with self._http_client() as client:
             response = client.post(
-                "/api/activities/upload",
-                files=[("files", f) for f in files],
+                url="/api/v1/traces/",
+                json={
+                    "timestamp": timestamp.isoformat(),
+                    "lactate": lactate,
+                    "rpe": rpe,
+                    "notes": notes,
+                    "power": power,
+                    "speed": speed,
+                    "heart_rate": heart_rate,
+                    "tags": tags,
+                },
+            )
+            response.raise_for_status()
+            return TraceDetails.model_validate(response.json())
+    def get_sports(self, only_root: bool = False) -> list[Sport]:
+        with self._http_client() as client:
+            response = client.get(
+                url="/api/v1/profile/sports/",
+                params={"only_root": only_root},
             )
             response.raise_for_status()
+            return [Sport(sport) for sport in response.json()]
+    def get_tags(self) -> list[str]:
+        with self._http_client() as client:
+            response = client.get(
+                url="/api/v1/profile/tags/",
+            )
+            response.raise_for_status()
             return response.json()
-    def _preprocess_file(self, file):
-        if isinstance(file, (str, Path)):
-            file = open(file, "rb")
-        elif isinstance(file, IOBase):
-            file = file
-        else:
-            raise ValueError("File must be a path (string or pathlib.Path) or a file-like object")
-        return file
-    def upload_activity(self, file):
-        file = self._preprocess_file(file)
-        self._upload_activity([file])
-    def batch_upload_activities(self, *, files: List[Union[str, Path, IOBase]] = None, directory: Union[str, Path] = None):
-        if files is not None and directory is not None:
-            raise ValueError("Only one of files or directory can be provided")
-        elif files is None and directory is None:
-            raise ValueError("One of files or directory must be provided")
+_default_client = Client()
+def _generate_singleton_methods(method_names: List[str]) -> None:
+    """
+    Automatically generates singleton methods for the Client class.
+    Args:
+        method_names: List of method names to expose in the singleton interface
+    """
+    def create_singleton_method(method_name: str):
+        bound_method = getattr(_default_client, method_name)
+        @wraps(bound_method)
+        def singleton_method(*args: Any, **kwargs: Any) -> Any:
+            return bound_method(*args, **kwargs)
+        class_method = getattr(Client, method_name)
+        singleton_method.__annotations__ = get_type_hints(class_method)
+        return singleton_method
+    for method_name in method_names:
+        if not hasattr(Client, method_name):
+            raise ValueError(f"Method '{method_name}' not found in class {Client.__name__}")
+        class_method = getattr(Client, method_name)
-        if directory is not None:
-            path = Path(directory)
-            if not path.exists() or not path.is_dir():
-                raise ValueError("Directory does not exist")
-            files = [self._preprocess_file(file) for file in path.glob("*.fit")]
-        else:
-            files = [self._preprocess_file(file) for file in files]
-        with ProgressBar("Uploading activity files", len(files)) as progress_bar:
-            progress_bar.show_progress(0)
-            for i in range(0, len(files), 10):
-                chunk = files[i:i+10]
-                self._upload_activity(chunk)
-                progress_bar.show_progress(i)
-_instance = SweatStack()
-login = _instance.login
-list_users = _instance.list_users
-list_accessible_users = _instance.list_accessible_users
-switch_user = _instance.switch_user
-switch_to_root_user = _instance.switch_to_root_user
-whoami = _instance.whoami
-list_activities = _instance.list_activities
-get_activity = _instance.get_activity
-get_latest_activity = _instance.get_latest_activity
-get_activity_data = _instance.get_activity_data
-get_latest_activity_data = _instance.get_latest_activity_data
-upload_activity = _instance.upload_activity
-batch_upload_activities = _instance.batch_upload_activities
-get_accumulated_work_duration = _instance.get_accumulated_work_duration
-get_mean_max = _instance.get_mean_max
-get_longitudinal_data = _instance.get_longitudinal_data
-try:
-    plot_activity_data = _instance.plot_activity_data
-    plot_latest_activity_data = _instance.plot_latest_activity_data
-    plot_scatter = _instance.plot_scatter
-    plot_mean_max = _instance.plot_mean_max
-except AttributeError:
-    # This is the case when the user has not installed the plotting dependencies
-    pass
+        if not callable(class_method):
+            continue
+        globals()[method_name] = create_singleton_method(method_name)
+_generate_singleton_methods(
+    [
+        "login",
+        "get_activities",
+        "get_activity",
+        "get_activity_data",
+        "get_activity_mean_max",
+        "get_latest_activity",
+        "get_latest_activity_data",
+        "get_latest_activity_mean_max",
+        "get_longitudinal_data",
+        "get_longitudinal_mean_max",
+        "get_traces",
+        "create_trace",
+        "get_sports",
+        "get_tags",
+    ]
+)

sweatstack 0.11.1__py3-none-any.whl → 0.13.0__py3-none-any.whl

sweatstack 0.11.1py3-none-any.whl → 0.13.0py3-none-any.whl