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

sweatstack/plotting.py

@@ -1,251 +0,0 @@
-from typing import List, Tuple, Union
-from datetime import date
-
-import plotly.graph_objects as go
-from plotly.subplots import make_subplots
-
-from .schemas import Metric, Sport
-
-
-METRIC_LABELS = {
-    "power": "power [Watt]",
-    "heart_rate": "heart rate [bpm]",
-    "speed": "speed [m/s]",
-    "cadence": "cadence [/min])",
-    "distance": "distance [m]",
-}
-
-def get_metric_label(metric):
-    match metric:
-        case "power":
-            return "power [Watt]"
-        case "heart_rate":
-            return "heart rate [bpm]"
-        case "speed":
-            return "speed [m/s]"
-        case "cadence":
-            return "cadence [/min])"
-        case "distance":
-            return "distance [m]"
-        case "duration":
-            return "duration [s]"
-        case _:
-            return metric
-
-
-METRIC_COLORS = {
-    "power": "blue",
-    "heart_rate": "red",
-    "speed": "green",
-    "cadence": "orange",
-}
-
-
-plotting_backend = "plotly"
-
-
-class PlottingMixin:
-    def _get_plotting_backend(self):
-        global plotting_backend
-        match plotting_backend:
-            case "plotly":
-                return PlotlyPlottingBackend()
-            case _:
-                raise ValueError(f"Unsupported plotting backend: {plotting_backend}")
-
-    def plot_activity_data(self, activity_id, metrics=None, subplots=True):
-        plotting_backend = self._get_plotting_backend()
-
-        activity_data = self.get_activity_data(activity_id)
-
-        return plotting_backend.plot_activity_data(activity_data, metrics, subplots)
-
-    def plot_latest_activity_data(self, metrics=None, subplots=True):
-        latest_activity = self.get_latest_activity()
-        return self.plot_activity_data(latest_activity.id, metrics, subplots)
-    
-    def plot_scatter(self, x, y, x_label=None, y_label=None):
-        plotting_backend = self._get_plotting_backend()
-        return plotting_backend.plot_scatter(
-            x=x,
-            y=y,
-            x_label=x_label,
-            y_label=y_label
-        )
-
-    def plot_mean_max(
-        self,
-        *,
-        sport: Union[Sport, str],
-        metric: Union[Metric, str],
-        start: Union[date, str] = None,
-        end: Union[date, str] = None,
-        windows: List[Tuple[Union[date, str], Union[date, str]]] = None,
-    ):
-        if (start is not None or end is not None) and windows is not None:
-            raise ValueError("Cannot specify both start/end and windows")
-        
-        if windows is None:
-            windows = [(start, end)]
-        
-        data = []
-        for start, end in windows:
-            data.append(
-                (
-                    self.get_mean_max(
-                        sport=sport,
-                        metric=metric,
-                        start=start,
-                        end=end,
-                    ),
-                    start,
-                    end,
-                )
-            )
-        plotting_backend = self._get_plotting_backend()
-        return plotting_backend.plot_mean_max(data, metric)
-
-class BasePlottingBackend:
-    def plot_activity_data(self, data, metrics=None, subplots=True):
-        raise NotImplementedError("Subclass must implement abstract method")
-
-    def plot_scatter(self, x, y, x_label=None, y_label=None):
-        raise NotImplementedError("Subclass must implement abstract method")
-    
-    def plot_mean_max(self, data, metric):
-        raise NotImplementedError("Subclass must implement abstract method")
-    
-    def preprocess_metrics(self, metrics: List[str], columns: List[str]) -> List[Tuple[str, str, str]]:
-        """
-        Preprocess the given metrics.
-
-        Args:
-            metrics (List[str]): A list of metric names.
-
-        Returns:
-            List[Tuple[str, str, str]]: An ordered list of tuples, each containing
-            a metric name, its corresponding label, and its color.
-        """
-
-        if not metrics:
-            metrics = [col for col in columns if col not in ["sport", "sub_sport", "lap", "lap_trigger", "duration"]]
-        elif missing_metrics := set(metrics) - set(columns):
-            raise ValueError(f"The following metrics are not present in the data: {', '.join(missing_metrics)}")
-
-        priority_metrics = ["power", "heart_rate", "speed", "cadence"]
-        existing_priority_metrics = [metric for metric in priority_metrics if metric in metrics]
-        remaining_metrics = sorted(col for col in metrics if col not in existing_priority_metrics)
-
-        sorted_metrics = existing_priority_metrics + remaining_metrics
-
-        return [(metric, METRIC_LABELS.get(metric, metric), METRIC_COLORS.get(metric, None)) for metric in sorted_metrics]
-
-
-class PlotlyPlottingBackend(BasePlottingBackend):
-    def plot_activity_data(self, data, metrics=None, subplots=True):
-        metrics = self.preprocess_metrics(metrics, data.columns)
-        if subplots:
-            fig = make_subplots(
-                rows=len(metrics),
-                cols=1,
-                shared_xaxes=True,
-                vertical_spacing=0.02
-            )
-
-            for i, (metric, label, color) in enumerate(metrics, 1):
-                params = {}
-                if color:
-                    params["line"] = dict(color=color)
-                fig.add_trace(
-                    go.Scatter(
-                        x=data.index,
-                        y=data[metric],
-                        name=metric,
-                        **params,
-                    ),
-                    row=i,
-                    col=1,
-                )
-            
-                fig.update_layout(
-                    height=600,
-                    yaxis_title=metrics[0][1],
-                    hovermode="x unified",
-                    spikedistance=-1,
-                    hoverdistance=-1,
-                )
-                fig.update_yaxes(
-                    title_text=label,
-                    row=i,
-                    col=1,
-                )
-
-        else:
-            fig = go.Figure()
-            for i, (metric, label, color) in enumerate(metrics):
-                params = {}
-                if color:
-                    params["line"] = dict(color=color)
-                fig.add_trace(
-                    go.Scatter(
-                        x=data.index,
-                        y=data[metric],
-                        name=metric,
-                        yaxis=f"y{i+1}",
-                        **params,
-                    )
-                )
-                if i > 0:
-                    fig.update_layout({
-                        f'yaxis{i+1}': {'overlaying': 'y', 'side': 'right', 'title': label, "position": 1 - (i * 0.07), "color": color}
-                    
-                    })
-                else:
-                    fig.update_layout({
-                        "yaxis1": {"color": color}
-                    })
-
-            
-            fig.update_layout(
-                height=600,
-                yaxis_title=metrics[0][1],
-                xaxis=dict(domain=[0, 1 - (len(metrics) - 1) * 0.07]),
-                hovermode="x unified",
-                spikedistance=-1,
-                hoverdistance=-1,
-            )
-        
-        return fig
-
-    def plot_scatter(self, x, y, x_label=None, y_label=None):
-        fig = go.Figure(
-            data=go.Scatter(x=x, y=y, mode='markers'),
-            layout=go.Layout(
-                xaxis_title=x_label if x_label is not None else x.name,
-                yaxis_title=y_label if y_label is not None else y.name,
-                width=800,
-                height=800
-            )
-        )
-        
-        fig.show()
-    
-    def plot_mean_max(self, data, metric):
-        fig = go.Figure()
-        for mean_max, start, end in data:
-            fig.add_trace(
-                go.Scatter(
-                x=mean_max.dt.total_seconds(),
-                y=mean_max.index,
-                name=f"{start if start is not None else ''} - {end if end is not None else ''}",
-                mode="lines",
-                )
-            )
-        fig.update_layout(
-            xaxis_title=get_metric_label("duration"),
-            yaxis_title=get_metric_label(metric),
-            xaxis_type="log",
-            width=800,
-            height=600
-        )
-        fig.show()

sweatstack-0.11.1.dist-info/METADATA

@@ -1,359 +0,0 @@
-Metadata-Version: 2.3
-Name: sweatstack
-Version: 0.11.1
-Summary: The official Python library for SweatStack
-Requires-Python: >=3.10
-Requires-Dist: pandas
-Requires-Dist: pydantic
-Requires-Dist: requests
-Provides-Extra: dev
-Requires-Dist: datamodel-code-generator; extra == 'dev'
-Provides-Extra: ipython
-Requires-Dist: ipython; extra == 'ipython'
-Requires-Dist: pyarrow; extra == 'ipython'
-Provides-Extra: jupyterlab
-Requires-Dist: jupyterlab; extra == 'jupyterlab'
-Requires-Dist: matplotlib; extra == 'jupyterlab'
-Requires-Dist: plotly; extra == 'jupyterlab'
-Requires-Dist: pyarrow; extra == 'jupyterlab'
-Provides-Extra: parquet
-Requires-Dist: pyarrow; extra == 'parquet'
-Provides-Extra: plotting
-Requires-Dist: matplotlib; extra == 'plotting'
-Requires-Dist: nbformat; extra == 'plotting'
-Requires-Dist: plotly; extra == 'plotting'
-Description-Content-Type: text/markdown
-
-# SweatStack Python Library
-
-## Overview
-
-This is the Python library for [Sweat Stack](https://sweatstack.no), a powerfull application designed for athletes, coaches, and sports scientists to analyze athletic performance data. This library provides a seamless interface to interact with the SweatStack API, allowing users to retrieve, analyze, and visualize activity data 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
-python -m pip install sweatstack
-```
-
-## Quickstart
-
-If you have `uv` installed, the fastest way to get started is to run the following command in your terminal:
-```
-uvx --from "sweatstack[jupyterlab]" sweatlab
-```
-
-This will open a JupyterLab instance with the SweatStack library pre-imported and authenticated via the browser authentication flow.
-
-```
-uvx --from "sweatstack[ipython]" sweatshell
-```
-
-This will open an interactive Python shell with the SweatStack library pre-imported and it will automatically trigger the browser authentication flow.
-
-Alternatively, you can open a Python shell of your own choice, install the library and get started:
-
-```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
-import sweatstack as ss
-
-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
-import sweatstack as ss
-
-activity = ss.get_activity(activity_id)
-print(activity)
-```
-
-To quickly the latest activity, you can use the `get_latest_activity()` function:
-
-```python
-import sweatstack as ss
-
-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
-import sweatstack as ss
-
-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
-import sweatstack as ss
-
-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
-import sweatstack as ss
-
-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` library with this extra dependency:
-```
-uv pip install sweatstack[parquet]
-```
-
-Also note that depending on the amount of data that you requested, this might take a while.
-
-
-## Plotting
-
-To plot data, there are a few plotting methods available.
-
-```python
-import sweatstack as ss
-
-ss.plot_activity_data(activity_id)
-```
-...wil plot the all the available columns from the specified activity.
-There is also a `ss.plot_latest_activity_data()` method that will plot the latest activity data.
-
-Additionally, there is a `ss.plot_data()` method that you can use to for example plot longitudinal data or for more generic use. This method requires you to pass the actual data as a pandas DataFrame and will not work with the activity id's used above.
-
-```python
-import sweatstack as ss
-
-ss.plot_data(data)
-```
-
-All of these methods accept a `metrics` argument, which is a list of metrics that you want to plot, as well as a `subplots` argument, which is a boolean that specifies whether you want to plot each metrics in subplots or not.
-Example:
-
-```python
-import sweatstack as ss
-
-ss.plot_latest_activity_data(metrics=["heart_rate", "power"], subplots=True)
-ss.plot_data(data, metrics=["heart_rate", "power"], subplots=False)
-```
-
-There is also a `ss.plot_scatter()` method that you can use to plot a scatter plot of any two metrics:
-
-```python
-import sweatstack as ss
-
-ss.plot_scatter(x=data["power"], y=data["heart_rate"])
-```
-
-For plotting mean-max data, you can use the `ss.plot_mean_max()` method:
-
-```python
-import sweatstack as ss
-
-ss.plot_mean_max(
-    sport="running",
-    metric="power",
-)
-```
-By default, this method will plot the mean-max data for the last 30 days.
-But you can provide explicit start and end dates (both optional) to plot the mean-max data for a different time period and these can provided as both `date` objects and `str` objects (e.g. "1970-01-01").
-
-```python
-from datetime import date, timedelta
-
-import sweatstack as ss
-
-ss.plot_mean_max(
-    sport="running",
-    metric="power",
-    start=date.today() - timedelta(days=180),
-    end=date.today(),
-)
-```
-
-To plot the mean-max data for multiple time windows, you can provide a list of start and end dates as the `windows` argument:
-
-```python
-from datetime import date, timedelta
-
-import sweatstack as ss
-
-ss.plot_mean_max(
-    sport="running",
-    metric="power",
-    windows=[
-        (date.today() - timedelta(days=180), date.today()),
-        (date.today() - timedelta(days=30), date.today() - timedelta(days=180)),
-    ],
-)
-```
-
-This opens up a lot of possibilities, for example to plot the mean-max data for each 30 day window in the last 300 days:
-```python
-from datetime import date, timedelta
-
-import sweatstack as ss
-
-ss.plot_mean_max(
-    sport="running",
-    metric="power",
-    windows=[(date.today() - timedelta(days=i + 30), date.today() - timedelta(days=i + 1)) for i in range(0, 120, 30)],
-)
-```
-
-At the moment, only the Plotly plotting backend is available, but more plotting backends (like Matplotlib) will be added in the future.
-
-Please note that these plotting methods are just there for your convenience.
-If you want to customize your plots, we recommend using a plotting library like Plotly or Matplotlib directly.
-[This](https://pandas.pydata.org/docs/user_guide/visualization.html) page from the pandas documentation gives a good overview of the available plotting options for the `pandas.DataFrames` and `pandas.Series` that this library returns.
-
-
-## 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
-import sweatstack as ss
-
-for user in ss.list_accessible_users():
-    print(user)
-```
-
-You can switch to another user by using the `switch_user()` method:
-
-```python
-import sweatstack as ss
-
-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
-import sweatstack as ss
-
-ss.switch_to_root_user()
-```
-
-
-## Uploading activities
-
-To upload activities (only .fit files at this moment), you can use the `upload_activity()` method:
-
-```python
-ss.upload_activity("path/to/activity.fit")
-```
-
-To upload multiple activities, you can use the `batch_upload_activities()` method:
-```python
-import sweatstack as ss
-
-ss.batch_upload_activities(files=["path/to/activity1.fit", "path/to/activity2.fit", "path/to/activity3.fit"])
-``` 
-
-For both the `upload_activity()` and `batch_upload_activities()` methods, you can pass files as a file path (string or pathlib.Path) or file-like object.
-
-In addition to this, `batch_upload_activities()` also accepts a `directory` argument (string or pathlib.Path), allowing you to upload all activities in a directory:
-
-```python
-import sweatstack as ss
-
-ss.batch_upload_activities(directory="path/to/directory")
-```
-
-
-## 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.11.1.dist-info/RECORD

@@ -1,13 +0,0 @@
-sweatstack/__init__.py,sha256=tiVfgKlswRPaDMEy0gA7u8rveqEYZTA_kyB9lJ3J6Sc,21
-sweatstack/cli.py,sha256=dYgvMOSGFC5ol_Z_2DYSOdNPQlHGsRIfh4y4qCmBLME,712
-sweatstack/client.py,sha256=0ll_CglekhruGZlgvRETElr3xDxXiw5Q-bIdyR0Tt_E,20174
-sweatstack/ipython_init.py,sha256=zBGUlMFkdpLvsNpOpwrNaKRUpUZhzaICvH8ODJgMPcI,229
-sweatstack/jupyterlab_oauth2_startup.py,sha256=rMAXH4KINI-FitNSumnUSy7oS9CoKajhNxFyERSimHw,1005
-sweatstack/plotting.py,sha256=t21he_YYoOQAGR6UiXBtv01fRd2TydC88pYouzR676w,8229
-sweatstack/schemas.py,sha256=I-30xwI6HjZ60np3wBdP9IBL9SIFyF5Tj1q7MMOtvuI,8802
-sweatstack/sweatshell.py,sha256=MYLNcWbOdceqKJ3S0Pe8dwHXEeYsGJNjQoYUXpMTftA,333
-sweatstack/Sweat Stack examples/Getting started.ipynb,sha256=k2hiSffWecoQ0VxjdpDcgFzBXDQiYEebhnAYlu8cgX8,6335204
-sweatstack-0.11.1.dist-info/METADATA,sha256=0gaAm2NfzLLVSY889VsSby75kfe_qYPC8prJS0isLQo,10477
-sweatstack-0.11.1.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-sweatstack-0.11.1.dist-info/entry_points.txt,sha256=kCzOUQI3dqbTpEYqtgYDeiKFaqaA7BMlV6D24BMzCFU,208
-sweatstack-0.11.1.dist-info/RECORD,,