sweatstack 0.1.0__tar.gz

sweatstack-0.1.0/.gitignore

@@ -0,0 +1,9 @@
+.env
+.env.*
+!.env.template
+.venv
+__pycache__
+GCP_CREDENTIALS
+**/.DS_Store
+*.egg-info
+.vscode

sweatstack-0.1.0/PKG-INFO

@@ -0,0 +1,186 @@
+Metadata-Version: 2.3
+Name: sweatstack
+Version: 0.1.0
+Summary: The official Python library for SweatStack
+Requires-Python: >=3.10
+Requires-Dist: httpx
+Requires-Dist: pandas
+Requires-Dist: pydantic
+Provides-Extra: dev
+Requires-Dist: datamodel-code-generator; extra == 'dev'
+Provides-Extra: ipython
+Requires-Dist: ipython; extra == 'ipython'
+Provides-Extra: parquet
+Requires-Dist: pyarrow; extra == 'parquet'
+Description-Content-Type: text/markdown
+
+# SweatStack Python Library
+
+## Overview
+
+SweatStack is a powerful Python library designed for athletes, coaches, and sports scientists to analyze and manage athletic performance data. It provides a seamless interface to interact with the SweatStack API, allowing users to retrieve, analyze, and visualize activity data, user information, and performance metrics.
+
+## Installation
+
+We recommend using `uv` to manage Python and install the library.
+Read more about `uv` [here](https://docs.astral.sh/uv/getting-started/).
+
+```bash
+uv pip install sweatstack
+```
+
+You can also install it with `pip` (or `pipx`) directly.
+```bash
+pip install sweatstack
+```
+
+## Quickstart
+
+Get started with analyzing your latest activity:
+
+```python
+import sweatstack as ss
+
+ss.login()
+
+latest_activity = ss.get_latest_activity()
+
+print(latest_activity)  # `latest_activity` is a pandas DataFrame
+```
+
+
+## Authentication
+
+To be able to access your data in Sweat Stack, you need to authenticate the library with your Sweat Stack account.
+The easiest way to do this is to use your browser to login:
+
+```python
+import sweatstack as ss
+
+ss.login()
+```
+This will automaticallyset the appropriate authentication tokens in your Python code.
+
+Alternatively, you can set the `SWEAT_STACK_API_KEY` environment variable to your API key.
+You can create an API key [here](https://app.sweatstack.com/account/api-keys).
+
+```python
+import os
+
+import sweatstack as ss
+
+os.environ["SWEAT_STACK_API_KEY"] = "your_api_key_here"
+
+# Now you can use the library
+```
+
+
+## Listing activities
+
+To list activities, you can use the `list_activities()` function:
+
+```python
+for activity in ss.list_activities():
+    print(activity)
+```
+> **Info:** This method returns a summary of the activities, not the actual timeseries data.
+> To get the actual data, you need to use the `get_activity_data()` or `get_latest_activity_data()`) methods documented below.
+
+## Getting activity summaries
+
+To get the summary of an activity, you can use the `get_activity()` function:
+
+```python
+activity = ss.get_activity(activity_id)
+print(activity)
+```
+
+To quickly the latest activity, you can use the `get_latest_activity()` function:
+
+```python
+activity = ss.get_latest_activity()
+print(activity)
+```
+
+## Getting activity data
+
+To get the timeseries data of one activity, you can use the `get_activity_data()` method:
+
+```python
+data = ss.get_activity_data(activity_id)
+print(data)
+```
+
+This method returns a pandas DataFrame.
+If your are not familiar with pandas and/or DataFrames, start by reading this [introduction](https://pandas.pydata.org/docs/user_guide/10min.html).
+
+Similar as for the summaries, you can use the `get_latest_activity_data()` method to get the timeseries data of the latest activity:
+
+```python
+data = ss.get_latest_activity_data()
+print(data)
+```
+
+To get the timeseries data of multiple activities, you can use the `get_longitudinal_data()` method:
+
+```python
+longitudinal_data = ss.get_longitudinal_data(
+    start=date.today() - timedelta(days=180),
+    sport="running",
+    metrics=["power", "heart_rate"],
+)
+print(longitudinal_data)
+```
+
+Because the result of `get_longitudinal_data()` can be very large, the data is retrieved in a compressed format (parquet) that requires the `pyarrow` library to be installed. If you intend to use this method, make sure to install the `sweatstack` libraryr with `uv pip install sweatstack[parquet]`.
+Also note that depending on the amount of data that you requested, this might take a while.
+
+## Accessing other user's data
+
+By default, the library will give you access to your own data.
+
+You can list all users you have access to with the `list_accessible_users()` method:
+
+```python
+for user in ss.list_accessible_users():
+    print(user)
+```
+
+You can switch to another user by using the `switch_user()` method:
+
+```python
+ss.switch_user(user)
+```
+
+Calling any of the methods above will return the data for the user you switched to.
+
+You can easily switch back to your original user by calling the `switch_to_root_user()` method:
+
+```python
+ss.switch_to_root_user()
+```
+
+
+## Metrics
+
+The API supports the following metrics:
+- `power`: Power in Watt
+- `speed`: Speed in m/s
+- `heart_rate`: Heart rate in BPM
+- `smo2`: Muscle oxygen saturation in %
+- `core_temperature`: Core body temperature in °C
+- `altitude`: Altitude in meters
+- `cadence`: Cadence in RPM
+- `temperature`: Ambient temperature in °C
+- `distance`: Distance in m
+- `longitude`: Longitude in degrees
+- `latitude`: Latitude in degrees
+
+
+## Sports
+
+The API supports the following sports:
+- `running`: Running
+- `cycling`: Cycling
+
+More sports will be added in the future.

sweatstack-0.1.0/README.md

@@ -0,0 +1,170 @@
+# SweatStack Python Library
+
+## Overview
+
+SweatStack is a powerful Python library designed for athletes, coaches, and sports scientists to analyze and manage athletic performance data. It provides a seamless interface to interact with the SweatStack API, allowing users to retrieve, analyze, and visualize activity data, user information, and performance metrics.
+
+## Installation
+
+We recommend using `uv` to manage Python and install the library.
+Read more about `uv` [here](https://docs.astral.sh/uv/getting-started/).
+
+```bash
+uv pip install sweatstack
+```
+
+You can also install it with `pip` (or `pipx`) directly.
+```bash
+pip install sweatstack
+```
+
+## Quickstart
+
+Get started with analyzing your latest activity:
+
+```python
+import sweatstack as ss
+
+ss.login()
+
+latest_activity = ss.get_latest_activity()
+
+print(latest_activity)  # `latest_activity` is a pandas DataFrame
+```
+
+
+## Authentication
+
+To be able to access your data in Sweat Stack, you need to authenticate the library with your Sweat Stack account.
+The easiest way to do this is to use your browser to login:
+
+```python
+import sweatstack as ss
+
+ss.login()
+```
+This will automaticallyset the appropriate authentication tokens in your Python code.
+
+Alternatively, you can set the `SWEAT_STACK_API_KEY` environment variable to your API key.
+You can create an API key [here](https://app.sweatstack.com/account/api-keys).
+
+```python
+import os
+
+import sweatstack as ss
+
+os.environ["SWEAT_STACK_API_KEY"] = "your_api_key_here"
+
+# Now you can use the library
+```
+
+
+## Listing activities
+
+To list activities, you can use the `list_activities()` function:
+
+```python
+for activity in ss.list_activities():
+    print(activity)
+```
+> **Info:** This method returns a summary of the activities, not the actual timeseries data.
+> To get the actual data, you need to use the `get_activity_data()` or `get_latest_activity_data()`) methods documented below.
+
+## Getting activity summaries
+
+To get the summary of an activity, you can use the `get_activity()` function:
+
+```python
+activity = ss.get_activity(activity_id)
+print(activity)
+```
+
+To quickly the latest activity, you can use the `get_latest_activity()` function:
+
+```python
+activity = ss.get_latest_activity()
+print(activity)
+```
+
+## Getting activity data
+
+To get the timeseries data of one activity, you can use the `get_activity_data()` method:
+
+```python
+data = ss.get_activity_data(activity_id)
+print(data)
+```
+
+This method returns a pandas DataFrame.
+If your are not familiar with pandas and/or DataFrames, start by reading this [introduction](https://pandas.pydata.org/docs/user_guide/10min.html).
+
+Similar as for the summaries, you can use the `get_latest_activity_data()` method to get the timeseries data of the latest activity:
+
+```python
+data = ss.get_latest_activity_data()
+print(data)
+```
+
+To get the timeseries data of multiple activities, you can use the `get_longitudinal_data()` method:
+
+```python
+longitudinal_data = ss.get_longitudinal_data(
+    start=date.today() - timedelta(days=180),
+    sport="running",
+    metrics=["power", "heart_rate"],
+)
+print(longitudinal_data)
+```
+
+Because the result of `get_longitudinal_data()` can be very large, the data is retrieved in a compressed format (parquet) that requires the `pyarrow` library to be installed. If you intend to use this method, make sure to install the `sweatstack` libraryr with `uv pip install sweatstack[parquet]`.
+Also note that depending on the amount of data that you requested, this might take a while.
+
+## Accessing other user's data
+
+By default, the library will give you access to your own data.
+
+You can list all users you have access to with the `list_accessible_users()` method:
+
+```python
+for user in ss.list_accessible_users():
+    print(user)
+```
+
+You can switch to another user by using the `switch_user()` method:
+
+```python
+ss.switch_user(user)
+```
+
+Calling any of the methods above will return the data for the user you switched to.
+
+You can easily switch back to your original user by calling the `switch_to_root_user()` method:
+
+```python
+ss.switch_to_root_user()
+```
+
+
+## Metrics
+
+The API supports the following metrics:
+- `power`: Power in Watt
+- `speed`: Speed in m/s
+- `heart_rate`: Heart rate in BPM
+- `smo2`: Muscle oxygen saturation in %
+- `core_temperature`: Core body temperature in °C
+- `altitude`: Altitude in meters
+- `cadence`: Cadence in RPM
+- `temperature`: Ambient temperature in °C
+- `distance`: Distance in m
+- `longitude`: Longitude in degrees
+- `latitude`: Latitude in degrees
+
+
+## Sports
+
+The API supports the following sports:
+- `running`: Running
+- `cycling`: Cycling
+
+More sports will be added in the future.

sweatstack-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[project]
+name = "sweatstack"
+version = "0.1.0"
+description = "The official Python library for SweatStack"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "httpx",
+    "pandas",
+    "pydantic",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+
+[project.optional-dependencies]
+dev = [
+    "datamodel-code-generator",
+]
+parquet = [
+    "pyarrow",
+]
+ipython = [
+    "ipython",
+]
+
+[project.scripts]
+generate-response-models = "sweatstack.cli:generate_response_models"
+sweatshell = "sweatstack.cli:run_ipython"

sweatstack-0.1.0/script.py

@@ -0,0 +1,25 @@
+import os
+from datetime import date
+
+from SweatStack import SweatStack
+
+
+os.environ["SWEAT_STACK_API_KEY"] = "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1R1A4SHhPc3R0NVVCZVgyMWVaOCIsImF6cCI6InVHUDhIeE9zdHQ1VUJlWDIxZVo4IiwiZXhwIjoxNzIwOTAzODM1LCJpYXQiOjE3MjAwMDM4MzV9.Nk4pWhTz3-qJpgvVlseI5FklBwjROS7GTaPN7gy7budia_0qWZZYx_8_cidhdrWfXZY7tOWPWv82yF9RZ3SQbmWxZbk9sydTKOKxX2g4mbj4WhbWg-muhU_BiIMMTZ-HtrWcesr_daoUZJuRUht8lzxHWsUT4cpleOGdN_yI9Wqcn_ZIr1njhRIXa8MaBWO0bxolpNa9a8iKxhUWw5sVJQaVIYidN0puhqaXCqZrrZNntdASbhCmHfWJeIeWlASZ7gtbGIaHTuI08tCrMZEj4Y0i-mAulT_zDtNNTevx6yL9LFSCuWl75euCLEph_2Ncw1yKzGB-wTSb6bP-solNSw"
+# os.environ["SWEAT_STACK_URL"] = "http://localhost:2400"
+
+def main():
+    client = SweatStack()
+    import time
+    t0 = time.time()
+    awd = client.get_accumulated_work_duration(
+        start=date(2024, 1, 1),
+        end=date(2024, 8, 1),
+        sport="running",
+        metric="power",
+    )
+    print(f"This took: {round(time.time() - t0, 2)} seconds")
+    print(awd)
+
+
+if __name__ == "__main__":
+    main()

sweatstack-0.1.0/setup.py.old

@@ -0,0 +1,26 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="sweatstack",
+    version='0.1',
+    packages=find_packages(),
+    install_requires=[
+        "httpx",
+        "pandas",
+        "pydantic",
+    ],
+    extras_require={
+        "parquet": [
+            "pyarrow",
+        ],
+        # 'plotting': ['matplotlib>=3.0'],  # Optional plotting feature
+        "dev": [
+            "datamodel-code-generator",
+        ],
+    },
+    entry_points={
+        "console_scripts": [
+            "generate-response-models = sweatstack.cli:generate_response_models"
+        ]
+    },
+)

sweatstack-0.1.0/src/python_library/__init__.py

@@ -0,0 +1,2 @@
+def hello() -> str:
+    return "Hello from python-library!"

sweatstack-0.1.0/sweatstack/__init__.py

@@ -0,0 +1 @@
+from .client import *

sweatstack-0.1.0/sweatstack/cli.py

@@ -0,0 +1,38 @@
+import os
+import httpx
+from pathlib import Path
+
+from IPython import start_ipython
+
+from datamodel_code_generator import InputFileType, generate
+from datamodel_code_generator import DataModelType
+
+
+def generate_response_models():
+    response = httpx.get("http://localhost:2400/openapi.json")
+    response.raise_for_status()
+    output_directory = Path(__file__).parent
+    output = Path(output_directory / "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,
+    )
+
+    model = output.read_text()
+    print(model)
+
+
+def run_ipython():
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    startup_script = os.path.join(script_dir, 'ipython_init.py')
+    
+    ipython_args = [
+        '--InteractiveShellApp.exec_files={}'.format(startup_script)
+    ]
+    
+    start_ipython(argv=ipython_args)

sweatstack-0.1.0/sweatstack/client.py

@@ -0,0 +1,383 @@
+
+import random
+import os
+import webbrowser
+from http.server import HTTPServer, BaseHTTPRequestHandler
+from io import BytesIO, StringIO
+from contextlib import contextmanager
+from datetime import date, datetime, timedelta, timezone
+from typing import Dict, Iterator, List,Union
+from urllib.parse import urlparse, parse_qs
+
+import httpx
+import pandas as pd
+try:
+    import pyarrow
+except ImportError:
+    pyarrow = None
+
+
+from .schemas import ActivityDetail, ActivitySummary, Metric, PermissionType, Sport, User
+
+
+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.
+            Window auto-closing in 5s...<br>
+        </p>
+    </article>
+    <script>
+        setTimeout(() => window.close(), 5000);
+    </script>
+</body>
+</html>
+"""
+
+
+JWT_ENV_VARIABLE = "SWEAT_STACK_API_KEY"
+
+try:
+    SWEAT_STACK_URL = os.environ["SWEAT_STACK_URL"]
+except KeyError:
+    SWEAT_STACK_URL = "https://sweat-stack-s7c65i4gka-ew.a.run.app"
+
+
+SWEAT_STACK_URL = "http://localhost:2400"
+
+
+class SweatStack:
+    def __init__(self):
+        self.jwt = os.environ.get(JWT_ENV_VARIABLE)
+        self.root_jwt = self.jwt
+    
+    def login(self):
+        class AuthHandler(BaseHTTPRequestHandler):
+            def log_message(self, format, *args):
+                # Override to disable logging
+                pass
+
+            def do_GET(self):
+                query = urlparse(self.path).query
+                params = parse_qs(query)
+                
+                if "jwt" in params:
+                    self.server.jwt = params["jwt"][0]
+                    self.send_response(200)
+                    self.send_header("Content-type", "text/html")
+                    self.end_headers()
+                    self.wfile.write(AUTH_SUCCESSFUL_RESPONSE.encode())
+                    self.server.server_close()
+
+        # Find an available port
+        while True:
+            port = random.randint(8000, 9000)
+            try:
+                server = HTTPServer(("localhost", port), AuthHandler)
+                break
+            except OSError:
+                continue
+
+        authorization_url = f"{SWEAT_STACK_URL}/auth/authorize-script?redirect_port={port}"
+        webbrowser.open(authorization_url)
+
+        print(f"Waiting for authorization... (listening on port {port})")
+        print(f"If not redirected, open the following URL in your browser: {authorization_url}")
+        print("")
+
+        server.timeout = 30
+        try:
+            server.handle_request()
+        except TimeoutError:
+            raise Exception("Sweat Stack Python login timed out after 30 seconds. Please try again.")
+
+        if hasattr(server, "jwt"):
+            self.jwt = server.jwt
+            print(f"Sweat Stack Python login successful.")
+        else:
+            raise Exception("Sweat Stack Python login failed. Please try again.")
+    
+    @contextmanager
+    def _httpx_client(self):
+        headers = {
+            "authorization": f"Bearer {self.jwt}"
+        }
+        with httpx.Client(
+            base_url=SWEAT_STACK_URL,
+            headers=headers,
+            timeout=30,
+        ) as client:
+            yield client
+
+    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 = {}
+
+        with self._httpx_client() as client:
+            response = client.get("/api/users/", params=params)
+            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:
+        with self._httpx_client() as client:
+            response = client.get("/api/users/me")
+            return User.model_validate(response.json())
+    
+    def get_delegated_token(self, user: Union[User, str]):
+        if isinstance(user, str):
+            user_id = user
+        else:
+            user_id = user.id
+
+        with self._httpx_client() as client:
+            response = client.get(
+                f"/api/users/{user_id}/delegated-token",
+            )
+            response.raise_for_status()
+            return response.json()["jwt"]
+    
+    def switch_user(self, user: Union[User, str]):
+        self.root_jwt = self.jwt
+        self.jwt = self.get_delegated_token(user)
+    
+    def switch_to_root_user(self):
+        """
+        Switch back to the root user by setting the JWT to the root JWT.
+        """
+        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]]:
+        activities_count = 0
+
+        params = {}
+        if sport is not None:
+            if isinstance(sport, Sport):
+                sport = sport.value
+            params["sport"] = sport
+
+        if start is not None:
+            params["start"] = self._check_timezone_aware(start).isoformat()
+
+        if end is not None:
+            params["end"] = self._check_timezone_aware(end).isoformat()
+
+        with self._httpx_client() as client:
+            step_size = 50
+            offset = 0
+
+            while True:
+                params["limit"] = step_size
+                params["offset"] = offset
+                response = client.get("/api/activities/", params=params)
+                activities = response.json()
+
+                for activity in activities:
+                    activities_count += 1
+                    if limit is not None and activities_count > limit:
+                        break
+                    yield ActivitySummary(**activity) if as_pydantic else activity
+
+                if limit is not None and activities_count > limit or len(activities) < step_size:
+                    break
+
+                offset += step_size
+
+
+    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]:
+        if as_dataframe:
+            return pd.DataFrame(self._fetch_activities(limit=limit))
+        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
+
+        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()
+        
+
+        with self._httpx_client() as client:
+            response = client.get(f"/api/activities/timeseries", params=params)
+            buffer = BytesIO(response.content)
+            data = pd.read_parquet(buffer, engine="pyarrow")
+            return data
+
+    def get_activity(self, activity_id: str) -> ActivityDetail:
+        with self._httpx_client() as client:
+            response = client.get(f"/api/activities/{activity_id}")
+            return ActivityDetail(**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) -> pd.DataFrame:
+        with self._httpx_client() as client:
+            response = client.get(f"/api/activities/{activity_id}/timeseries")
+            data = pd.read_json(StringIO(response.json()), orient="split")
+            data.index = pd.to_datetime(data.index)
+            return data
+        
+    def get_latest_activity_data(self) -> pd.DataFrame:
+        activity = self.get_latest_activity()
+        return self.get_activity_data(activity.id)
+
+    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)
+
+        if end is None:
+            end = date.today()
+        if not isinstance(end, date):
+            end = date.fromisoformat(end)
+
+        if not isinstance(metric, Metric):
+            metric = Metric(metric)
+        if not isinstance(sport, Sport):
+            sport = Sport(sport)
+
+        with self._httpx_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,
+                }
+            )
+
+            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
+
+    def get_mean_max(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)
+
+        if end is None:
+            end = date.today()
+        if not isinstance(end, date):
+            end = date.fromisoformat(end)
+
+        if not isinstance(metric, Metric):
+            metric = Metric(metric)
+        if not isinstance(sport, Sport):
+            sport = Sport(sport)
+
+        with self._httpx_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,
+                }
+            )
+
+            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
+        
+
+_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
+
+get_accumulated_work_duration = _instance.get_accumulated_work_duration
+get_mean_max = _instance.get_mean_max
+get_longitudinal_data = _instance.get_longitudinal_data

sweatstack-0.1.0/sweatstack/ipython_init.py

@@ -0,0 +1,12 @@
+import time
+
+import sweatstack as ss
+
+
+print("\n")
+print(">>>>>>>>>> Sweat Stack Initialization <<<<<<<<<")
+print("Initializing....")
+print("You will be redirected to your browser for authentication.\n")
+time.sleep(2)
+
+ss.login()

sweatstack-0.1.0/sweatstack/schemas.py

@@ -0,0 +1,167 @@
+# generated by datamodel-codegen:
+#   filename:  openapi.json
+#   timestamp: 2024-08-29T12:58:42+00:00
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import List, Optional, Union
+
+from pydantic import AwareDatetime, BaseModel, Field, conint
+
+
+class ActivityLap(BaseModel):
+    start: AwareDatetime = Field(..., title='Start')
+    end: AwareDatetime = Field(..., title='End')
+    power: Optional[float] = Field(None, title='Power')
+    speed: Optional[float] = Field(None, title='Speed')
+    distance: Optional[float] = Field(None, title='Distance')
+    altitude: Optional[float] = Field(None, title='Altitude')
+    heart_rate: Optional[float] = Field(None, title='Heart Rate')
+    heart_rate_start: Optional[float] = Field(None, title='Heart Rate Start')
+    heart_rate_end: Optional[float] = Field(None, title='Heart Rate End')
+    cadence: Optional[float] = Field(None, title='Cadence')
+    temperature: Optional[float] = Field(None, title='Temperature')
+    core_temperature: Optional[float] = Field(None, title='Core Temperature')
+    smo2: Optional[float] = Field(None, title='Smo2')
+    duration: str = Field(..., title='Duration')
+
+
+class DelegatedTokenResponse(BaseModel):
+    jwt: str = Field(..., title='Jwt')
+
+
+class JWTResponse(BaseModel):
+    jwt: str = Field(..., title='Jwt')
+    refresh_token: str = Field(..., title='Refresh Token')
+
+
+class LapSyncData(BaseModel):
+    power: Optional[float] = Field(None, title='Power')
+    speed: Optional[float] = Field(None, title='Speed')
+    sport: str = Field(..., title='Sport')
+    activity: str = Field(..., title='Activity')
+
+
+class LapSyncedTrace(BaseModel):
+    timestamp: AwareDatetime = Field(..., title='Timestamp')
+    lactate: Optional[float] = Field(None, title='Lactate')
+    rpe: Optional[conint(ge=0, le=10)] = Field(
+        None,
+        description='Rating of Perceived Exertion (RPE) on the CR10 scale, ranging from 0 to 10:\n0 - No exertion at all\n1 - Very light\n2 - Light\n3 - Moderate\n4 - Somewhat hard\n5 - Hard\n6 - \n7 - Very hard\n8 - \n9 - Very, very hard\n10 - Maximum effort',
+        title='Rpe',
+    )
+    notes: Optional[str] = Field(None, title='Notes')
+    lap_sync: Optional[LapSyncData] = None
+
+
+class Metric(Enum):
+    power = 'power'
+    speed = 'speed'
+    heart_rate = 'heart_rate'
+    smo2 = 'smo2'
+    core_temperature = 'core_temperature'
+    altitude = 'altitude'
+    cadence = 'cadence'
+    temperature = 'temperature'
+    distance = 'distance'
+    longitude = 'longitude'
+    latitude = 'latitude'
+    lactate = 'lactate'
+    rpe = 'rpe'
+    notes = 'notes'
+
+
+class PermissionType(Enum):
+    granted = 'granted'
+    received = 'received'
+
+
+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'
+    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'
+    walking = 'walking'
+    hiking = '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'
+    rowing = 'rowing'
+    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'
+
+
+class Trace(BaseModel):
+    timestamp: AwareDatetime = Field(..., title='Timestamp')
+    lactate: Optional[float] = Field(None, title='Lactate')
+    rpe: Optional[conint(ge=0, le=10)] = Field(
+        None,
+        description='Rating of Perceived Exertion (RPE) on the CR10 scale, ranging from 0 to 10:\n0 - No exertion at all\n1 - Very light\n2 - Light\n3 - Moderate\n4 - Somewhat hard\n5 - Hard\n6 - \n7 - Very hard\n8 - \n9 - Very, very hard\n10 - Maximum effort',
+        title='Rpe',
+    )
+    notes: Optional[str] = Field(None, title='Notes')
+
+
+class User(BaseModel):
+    id: str = Field(..., title='Id')
+    first_name: Optional[str] = Field(None, title='First Name')
+    last_name: Optional[str] = Field(None, title='Last Name')
+    display_name: Optional[str] = Field(None, title='Display Name')
+    permission_types: Optional[List[PermissionType]] = Field(
+        None, title='Permission Types'
+    )
+
+
+class ValidationError(BaseModel):
+    loc: List[Union[str, int]] = Field(..., title='Location')
+    msg: str = Field(..., title='Message')
+    type: str = Field(..., title='Error Type')
+
+
+class ActivityDetail(BaseModel):
+    id: str = Field(..., title='Id')
+    title: Optional[str] = Field(None, title='Title')
+    start: AwareDatetime = Field(..., title='Start')
+    end: Optional[AwareDatetime] = Field(..., title='End')
+    sport: Sport
+    stationary: Optional[bool] = Field(None, title='Stationary')
+    metrics: Optional[List[Metric]] = Field([], title='Metrics')
+    laps: Optional[List[ActivityLap]] = Field([], title='Laps')
+    duration: Optional[str] = Field(..., title='Duration')
+    display_sport: Optional[str] = Field(..., title='Display Sport')
+
+
+class ActivitySummary(BaseModel):
+    id: str = Field(..., title='Id')
+    title: Optional[str] = Field(None, title='Title')
+    start: AwareDatetime = Field(..., title='Start')
+    end: Optional[AwareDatetime] = Field(..., title='End')
+    sport: Sport
+    stationary: Optional[bool] = Field(None, title='Stationary')
+    metrics: Optional[List[Metric]] = Field([], title='Metrics')
+    duration: Optional[str] = Field(..., title='Duration')
+    display_sport: Optional[str] = Field(..., title='Display Sport')
+
+
+class HTTPValidationError(BaseModel):
+    detail: Optional[List[ValidationError]] = Field(None, title='Detail')

sweatstack-0.1.0/test2.py

@@ -0,0 +1,91 @@
+from datetime import date, timedelta
+import sweatstack as ss
+
+
+import time
+
+start = time.time()
+ss.login()
+
+activities = list(ss.list_activities(as_dataframe=False))
+end = time.time()
+print(f"Time taken: {end - start} seconds")
+print(f"Number of activities: {len(activities)}")
+
+
+start = time.time()
+activities =  ss.list_activities(as_dataframe=True)
+end = time.time()
+
+print(f"Time taken: {end - start} seconds")
+print(f"Number of activities: {len(activities)}")
+print(activities.head())
+
+
+latest_activity = ss.get_latest_activity()
+print(f"{latest_activity=}")
+
+
+awd = ss.get_accumulated_work_duration(
+    start=date.today() - timedelta(days=90),
+    sport="running",
+    metric="power",
+)
+print(f"{awd=}")
+
+
+mean_max = ss.get_mean_max(
+    start=date.today() - timedelta(days=90),
+    sport="cycling",
+    metric="power",
+)
+print(f"{mean_max=}")
+
+users = ss.list_users()
+print(f"{users=}")
+
+users = ss.list_accessible_users()
+print(f"{users=}")
+print("")
+
+for user in users:
+    if user.last_name.lower() == "nistad":
+        jon_helge = user
+        break
+else:
+    raise Exception("Did not find Jon Helge!")
+
+user = ss.whoami()
+print(f"WHOAMI {user=}")
+print("")
+ss.switch_user(jon_helge)
+
+user = ss.whoami()
+print(f"WHOAMI {user=}")
+print("")
+
+activity = ss.get_latest_activity()
+print(f"{activity=}")
+print("")
+
+user = ss.whoami()
+print(f"WHOAMI {user=}")
+print("")
+
+ss.switch_to_root_user()
+user = ss.whoami()
+print(f"WHOAMI {user=}")
+print("")
+
+activity = ss.get_latest_activity()
+print(f"{activity=}")
+
+data = ss.get_latest_activity_data()
+print(f"{data=}")
+
+longitudinal_data = ss.get_longitudinal_data(
+    start=date.today() - timedelta(days=180),
+    sport="running",
+    metrics=["power", "heart_rate", "speed"],
+)
+print(f"{longitudinal_data.head()=}")