sweatstack 0.60.0__py3-none-any.whl → 0.61.0__py3-none-any.whl

sweatstack/fastapi/__init__.py

@@ -1,20 +1,52 @@
 """FastAPI integration for SweatStack authentication.
 
 This module provides OAuth authentication for FastAPI applications using
-SweatStack as the identity provider.
+SweatStack as the identity provider. It includes support for user switching,
+allowing applications like coaching platforms to view data on behalf of
+other users.
 
 Example:
     from fastapi import FastAPI
-    from sweatstack.fastapi import configure, instrument, AuthenticatedUser
+    from sweatstack.fastapi import configure, instrument, AuthenticatedUser, SelectedUser, urls
 
     configure()  # uses environment variables
 
     app = FastAPI()
     instrument(app)
 
-    @app.get("/me")
-    def get_me(user: AuthenticatedUser):
-        return user.client.get_userinfo()
+    @app.get("/activities")
+    def get_activities(user: SelectedUser):
+        # Returns activities for the currently selected user
+        return user.client.get_activities()
+
+    @app.get("/my-athletes")
+    def get_athletes(user: AuthenticatedUser):
+        # Always returns the principal user's accessible users
+        return user.client.get_users()
+
+User Switching:
+    The module supports two methods of user switching:
+
+    1. URL-based switching (recommended for web apps):
+        Use urls.select_user(user_id) and urls.select_self() in templates:
+
+        <form method="post" action="{{ urls.select_user(athlete.id) }}">
+            <button>View as {{ athlete.name }}</button>
+        </form>
+
+    2. Programmatic switching:
+        Call client.switch_user() in your endpoint code:
+
+        @app.post("/select/{athlete_id}")
+        def select(athlete_id: str, user: AuthenticatedUser):
+            user.client.switch_user(athlete_id)
+            return RedirectResponse("/dashboard")
+
+Dependency Types:
+    - AuthenticatedUser: Always returns the principal (logged-in) user
+    - OptionalUser: Returns principal or None if not authenticated
+    - SelectedUser: Returns the selected user (delegated or principal)
+    - OptionalSelectedUser: Returns selected user or None if not authenticated
 """
 
 try:
@@ -28,16 +60,23 @@ except ImportError:
 from .config import configure, urls
 from .dependencies import (
     AuthenticatedUser,
+    OptionalSelectedUser,
     OptionalUser,
+    SelectedUser,
     SweatStackUser,
 )
 from .routes import instrument
 
 __all__ = [
+    # Configuration
     "configure",
     "instrument",
+    "urls",
+    # User types
+    "SweatStackUser",
+    # Dependencies
     "AuthenticatedUser",
     "OptionalUser",
-    "SweatStackUser",
-    "urls",
+    "SelectedUser",
+    "OptionalSelectedUser",
 ]

sweatstack/fastapi/config.py

@@ -156,7 +156,20 @@ def get_config() -> FastAPIConfig:
 
 
 class _Urls:
-    """URL helpers for the FastAPI plugin."""
+    """URL helpers for the FastAPI plugin.
+
+    Provides methods to generate URLs for authentication and user selection routes.
+    These URLs can be used in templates or redirects.
+
+    Example:
+        from sweatstack.fastapi import urls
+
+        # In a template:
+        <a href="{{ urls.login() }}">Login</a>
+        <form method="post" action="{{ urls.select_user(athlete.id) }}">
+            <button>View as {{ athlete.name }}</button>
+        </form>
+    """
 
     def login(self, next: str | None = None) -> str:
         """Get the login URL.
@@ -173,5 +186,38 @@ class _Urls:
         """Get the logout URL."""
         return f"{get_config().auth_route_prefix}/logout"
 
+    def select_user(self, user_id: str, next: str | None = None) -> str:
+        """Get the URL to switch to viewing as another user.
+
+        Args:
+            user_id: The ID of the user to view as.
+            next: Optional path to redirect to after switching.
+
+        Example:
+            <form method="post" action="{{ urls.select_user(athlete.id) }}">
+                <button>View as {{ athlete.name }}</button>
+            </form>
+        """
+        base = f"{get_config().auth_route_prefix}/select-user/{user_id}"
+        if next:
+            return f"{base}?next={quote(next)}"
+        return base
+
+    def select_self(self, next: str | None = None) -> str:
+        """Get the URL to switch back to viewing as yourself.
+
+        Args:
+            next: Optional path to redirect to after switching.
+
+        Example:
+            <form method="post" action="{{ urls.select_self() }}">
+                <button>Back to my view</button>
+            </form>
+        """
+        base = f"{get_config().auth_route_prefix}/select-self"
+        if next:
+            return f"{base}?next={quote(next)}"
+        return base
+
 
 urls = _Urls()

sweatstack/fastapi/dependencies.py

@@ -1,9 +1,11 @@
 """FastAPI dependencies for authentication."""
 
+from __future__ import annotations
+
 import logging
 import time
 from dataclasses import dataclass
-from typing import Annotated, NoReturn, TypeAlias
+from typing import Annotated, NoReturn
 from urllib.parse import quote
 
 import httpx
@@ -13,6 +15,7 @@ from ..client import Client
 from ..constants import DEFAULT_URL
 from ..utils import decode_jwt_body
 from .config import get_config
+from .models import SessionData, TokenSet, extract_user_id
 from .session import (
     SESSION_COOKIE_NAME,
     clear_session_cookie,
@@ -20,33 +23,42 @@ from .session import (
     set_session_cookie,
 )
 
+logger = logging.getLogger(__name__)
+
 TOKEN_EXPIRY_MARGIN = 5  # seconds
 
 
-@dataclass
+@dataclass(slots=True)
 class SweatStackUser:
     """Authenticated SweatStack user.
 
     Attributes:
-        user_id: The user's SweatStack ID.
         client: An authenticated Client instance for API calls.
     """
 
-    user_id: str
     client: Client
 
+    @property
+    def user_id(self) -> str:
+        """The user ID this client acts as."""
+        return extract_user_id(self.client.api_key)
+
+
+# ---------------------------------------------------------------------------
+# Token refresh
+# ---------------------------------------------------------------------------
 
-def is_token_expiring(token: str) -> bool:
+
+def _is_token_expiring(token: str) -> bool:
     """Check if a token is within TOKEN_EXPIRY_MARGIN seconds of expiring."""
     try:
         body = decode_jwt_body(token)
         return body["exp"] - TOKEN_EXPIRY_MARGIN < time.time()
     except Exception:
-        # If we can't decode, assume it's expired
         return True
 
 
-def refresh_access_token(
+def _refresh_access_token(
     refresh_token: str,
     client_id: str,
     client_secret: str,
@@ -67,12 +79,39 @@ def refresh_access_token(
     return response.json()["access_token"]
 
 
-def _raise_unauthenticated(request: Request) -> NoReturn:
-    """Raise appropriate exception for unauthenticated requests.
+def _refresh_tokens_if_needed(tokens: TokenSet) -> TokenSet | None:
+    """Refresh tokens if the access token is expiring.
 
-    If redirect_unauthenticated is True, redirects to login with ?next= set.
-    Otherwise, raises 401 Unauthorized.
+    Returns new TokenSet if refreshed, None if no refresh needed.
     """
+    if not _is_token_expiring(tokens.access_token):
+        return None
+
+    token_body = decode_jwt_body(tokens.access_token)
+    tz = token_body.get("tz", "UTC")
+
+    config = get_config()
+    new_access_token = _refresh_access_token(
+        refresh_token=tokens.refresh_token,
+        client_id=config.client_id,
+        client_secret=config.client_secret.get_secret_value(),
+        tz=tz,
+    )
+
+    return TokenSet(
+        access_token=new_access_token,
+        refresh_token=tokens.refresh_token,
+        user_id=tokens.user_id,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Session helpers
+# ---------------------------------------------------------------------------
+
+
+def _raise_unauthenticated(request: Request) -> NoReturn:
+    """Raise appropriate exception for unauthenticated requests."""
     config = get_config()
     if config.redirect_unauthenticated:
         next_url = request.url.path
@@ -83,79 +122,172 @@ def _raise_unauthenticated(request: Request) -> NoReturn:
     raise HTTPException(status_code=401, detail="Not authenticated")
 
 
-def require_user(request: Request, response: Response) -> SweatStackUser:
-    """Dependency that requires an authenticated user.
-
-    Returns a SweatStackUser if the session is valid. If not authenticated,
-    behavior depends on the redirect_unauthenticated config:
-    - If True: redirects to login with ?next= set to current path
-    - If False: raises 401 Unauthorized
+def _get_session_or_raise(request: Request) -> SessionData:
+    """Get and validate session data, raising if invalid."""
+    raw_session = decrypt_session(request.cookies.get(SESSION_COOKIE_NAME))
+    if not raw_session:
+        _raise_unauthenticated(request)
 
-    Automatically refreshes tokens if they are about to expire.
-    """
-    session = decrypt_session(request.cookies.get(SESSION_COOKIE_NAME))
-    if not session:
+    try:
+        return SessionData.from_dict(raw_session)
+    except (KeyError, TypeError):
         _raise_unauthenticated(request)
 
-    access_token = session.get("access_token")
-    refresh_token = session.get("refresh_token")
-    user_id = session.get("user_id")
 
-    if not access_token or not user_id:
-        clear_session_cookie(response)
-        _raise_unauthenticated(request)
+def _get_session_or_none(request: Request) -> SessionData | None:
+    """Get session data if present and valid, None otherwise."""
+    raw_session = decrypt_session(request.cookies.get(SESSION_COOKIE_NAME))
+    if not raw_session:
+        return None
+
+    try:
+        return SessionData.from_dict(raw_session)
+    except (KeyError, TypeError):
+        return None
+
 
-    # Check if token needs refresh
-    if is_token_expiring(access_token):
-        if not refresh_token:
-            clear_session_cookie(response)
-            _raise_unauthenticated(request)
-
-        try:
-            # Extract timezone from current token
-            token_body = decode_jwt_body(access_token)
-            tz = token_body.get("tz", "UTC")
-
-            config = get_config()
-            new_access_token = refresh_access_token(
-                refresh_token=refresh_token,
-                client_id=config.client_id,
-                client_secret=config.client_secret,
-                tz=tz,
-            )
-
-            # Update session with new token
-            session["access_token"] = new_access_token
-            set_session_cookie(response, session)
-            access_token = new_access_token
-
-        except Exception:
-            logging.exception("Token refresh failed for user %s", user_id)
-            clear_session_cookie(response)
-            _raise_unauthenticated(request)
+# ---------------------------------------------------------------------------
+# Core dependency logic
+# ---------------------------------------------------------------------------
 
+
+def _create_user(
+    session: SessionData,
+    response: Response,
+    *,
+    use_delegated: bool,
+) -> SweatStackUser:
+    """Create user from session, refreshing tokens if needed."""
     config = get_config()
-    client = Client(
-        api_key=access_token,
-        refresh_token=refresh_token,
-        client_id=config.client_id,
-        client_secret=config.client_secret,  # Client accepts SecretStr directly
+
+    # Select which tokens to use
+    if use_delegated and session.delegated:
+        tokens = session.delegated
+        is_delegated = True
+    else:
+        tokens = session.principal
+        is_delegated = False
+
+    # Refresh tokens if needed and persist immediately
+    try:
+        refreshed = _refresh_tokens_if_needed(tokens)
+    except Exception:
+        logger.exception("Token refresh failed for user %s", tokens.user_id)
+        clear_session_cookie(response)
+        raise HTTPException(status_code=401, detail="Session expired")
+
+    if refreshed:
+        # Update session with refreshed tokens
+        if is_delegated:
+            session = SessionData(principal=session.principal, delegated=refreshed)
+        else:
+            session = SessionData(principal=refreshed, delegated=session.delegated)
+        tokens = refreshed
+        set_session_cookie(response, session.to_dict())
+
+    return SweatStackUser(
+        client=Client(
+            api_key=tokens.access_token,
+            refresh_token=tokens.refresh_token,
+            client_id=config.client_id,
+            client_secret=config.client_secret,
+        )
     )
-    return SweatStackUser(user_id=user_id, client=client)
 
 
-def optional_user(request: Request, response: Response) -> SweatStackUser | None:
-    """Dependency that optionally returns an authenticated user.
+# ---------------------------------------------------------------------------
+# Dependency functions
+# ---------------------------------------------------------------------------
 
-    Returns a SweatStackUser if the session is valid, None otherwise.
-    Does not raise exceptions for missing or invalid sessions.
-    """
+
+def _require_authenticated_user(
+    request: Request,
+    response: Response,
+) -> SweatStackUser:
+    """Dependency: always returns principal user."""
+    session = _get_session_or_raise(request)
+    return _create_user(session, response, use_delegated=False)
+
+
+def _require_selected_user(
+    request: Request,
+    response: Response,
+) -> SweatStackUser:
+    """Dependency: returns delegated user if selected, otherwise principal."""
+    session = _get_session_or_raise(request)
+    return _create_user(session, response, use_delegated=True)
+
+
+def _optional_authenticated_user(
+    request: Request,
+    response: Response,
+) -> SweatStackUser | None:
+    """Dependency: returns principal user or None."""
+    session = _get_session_or_none(request)
+    if not session:
+        return None
     try:
-        return require_user(request, response)
+        return _create_user(session, response, use_delegated=False)
     except HTTPException:
         return None
 
 
-# Type aliases for use in route handlers
-AuthenticatedUser: TypeAlias = Annotated[SweatStackUser, Depends(require_user)]
-OptionalUser: TypeAlias = Annotated[SweatStackUser | None, Depends(optional_user)]
+def _optional_selected_user(
+    request: Request,
+    response: Response,
+) -> SweatStackUser | None:
+    """Dependency: returns selected user or None."""
+    session = _get_session_or_none(request)
+    if not session:
+        return None
+    try:
+        return _create_user(session, response, use_delegated=True)
+    except HTTPException:
+        return None
+
+
+# ---------------------------------------------------------------------------
+# Public type aliases
+# ---------------------------------------------------------------------------
+
+AuthenticatedUser = Annotated[SweatStackUser, Depends(_require_authenticated_user)]
+"""Dependency that always returns the principal (logged-in) user.
+
+Example:
+    @app.get("/my-athletes")
+    def get_athletes(user: AuthenticatedUser):
+        return user.client.get_users()
+"""
+
+SelectedUser = Annotated[SweatStackUser, Depends(_require_selected_user)]
+"""Dependency that returns the currently selected user.
+
+Returns the delegated user if one is selected, otherwise the principal user.
+
+Example:
+    @app.get("/activities")
+    def get_activities(user: SelectedUser):
+        return user.client.get_activities()
+"""
+
+OptionalUser = Annotated[SweatStackUser | None, Depends(_optional_authenticated_user)]
+"""Dependency that returns the principal user or None if not authenticated.
+
+Example:
+    @app.get("/")
+    def home(user: OptionalUser):
+        if user:
+            return {"logged_in": True, "user_id": user.user_id}
+        return {"logged_in": False}
+"""
+
+OptionalSelectedUser = Annotated[SweatStackUser | None, Depends(_optional_selected_user)]
+"""Dependency that returns the selected user or None if not authenticated.
+
+Example:
+    @app.get("/public-profile")
+    def profile(user: OptionalSelectedUser):
+        if user:
+            return user.client.get_user()
+        return {"message": "Not logged in"}
+"""

sweatstack/fastapi/models.py

@@ -0,0 +1,109 @@
+"""Data models for FastAPI session management."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from pydantic import SecretStr
+
+from ..utils import decode_jwt_body
+
+
+@dataclass(frozen=True, slots=True)
+class TokenSet:
+    """Immutable token pair with user ID.
+
+    This represents either principal or delegated tokens stored in the session.
+    The frozen=True ensures tokens can't be accidentally modified.
+    """
+
+    access_token: str
+    refresh_token: str
+    user_id: str
+
+    def to_dict(self) -> dict[str, str]:
+        """Serialize to dictionary for session storage."""
+        return {
+            "access_token": self.access_token,
+            "refresh_token": self.refresh_token,
+            "user_id": self.user_id,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> TokenSet:
+        """Deserialize from dictionary."""
+        return cls(
+            access_token=data["access_token"],
+            refresh_token=data["refresh_token"],
+            user_id=data["user_id"],
+        )
+
+
+@dataclass(slots=True)
+class SessionData:
+    """Type-safe wrapper for session data.
+
+    Handles both the new format (with principal/delegated) and legacy format
+    (flat access_token/refresh_token/user_id) for backwards compatibility.
+    """
+
+    principal: TokenSet
+    delegated: TokenSet | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize to dictionary for cookie storage."""
+        data: dict[str, Any] = {"principal": self.principal.to_dict()}
+        if self.delegated:
+            data["delegated"] = self.delegated.to_dict()
+        return data
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> SessionData:
+        """Deserialize from dictionary.
+
+        Handles both new format and legacy format for backwards compatibility.
+        """
+        # New format: has "principal" key
+        if "principal" in data:
+            return cls(
+                principal=TokenSet.from_dict(data["principal"]),
+                delegated=TokenSet.from_dict(data["delegated"]) if data.get("delegated") else None,
+            )
+
+        # Legacy format: flat structure with access_token, refresh_token, user_id
+        # Migrate to new format by treating as principal
+        return cls(
+            principal=TokenSet(
+                access_token=data["access_token"],
+                refresh_token=data["refresh_token"],
+                user_id=data["user_id"],
+            ),
+            delegated=None,
+        )
+
+
+def extract_user_id(jwt_token: str | SecretStr) -> str:
+    """Extract user ID ('sub' claim) from a JWT token.
+
+    This does not validate the signature - the token was already validated
+    by the API when it was issued.
+
+    Args:
+        jwt_token: The JWT access token (str or SecretStr).
+
+    Returns:
+        The user ID from the token's 'sub' claim.
+
+    Raises:
+        ValueError: If the token is malformed or missing the 'sub' claim.
+    """
+    try:
+        token_str = jwt_token.get_secret_value() if isinstance(jwt_token, SecretStr) else jwt_token
+        payload = decode_jwt_body(token_str)
+        user_id = payload.get("sub")
+        if not user_id:
+            raise ValueError("Token missing 'sub' claim")
+        return user_id
+    except (IndexError, KeyError) as e:
+        raise ValueError(f"Malformed JWT token: {e}") from e

sweatstack/fastapi/routes.py

@@ -1,25 +1,33 @@
 """OAuth routes for the FastAPI plugin."""
 
+from __future__ import annotations
+
 import base64
 import json
+import logging
 import secrets
-from urllib.parse import urlencode
+from urllib.parse import urlencode, urlparse
 
 import httpx
-from fastapi import APIRouter, FastAPI, Request, Response
+from fastapi import APIRouter, FastAPI, HTTPException, Request, Response
 from fastapi.responses import RedirectResponse
 
 from ..constants import DEFAULT_URL
 from ..utils import decode_jwt_body
 from .config import get_config
+from .models import SessionData, TokenSet
 from .session import (
+    SESSION_COOKIE_NAME,
     STATE_COOKIE_NAME,
     clear_session_cookie,
     clear_state_cookie,
+    decrypt_session,
     set_session_cookie,
     set_state_cookie,
 )
 
+logger = logging.getLogger(__name__)
+
 
 def validate_redirect(url: str | None) -> str | None:
     """Validate that a redirect URL is a safe relative path.
@@ -31,6 +39,82 @@ def validate_redirect(url: str | None) -> str | None:
     return None
 
 
+def _is_same_origin(referer: str | None, app_url: str) -> bool:
+    """Check if a referer URL is from the same origin as the app."""
+    if not referer:
+        return False
+    try:
+        ref_parsed = urlparse(referer)
+        app_parsed = urlparse(app_url)
+        return (
+            ref_parsed.scheme == app_parsed.scheme
+            and ref_parsed.netloc == app_parsed.netloc
+        )
+    except Exception:
+        return False
+
+
+def _get_redirect_url(request: Request, next_param: str | None) -> str:
+    """Determine the redirect URL after a user selection change.
+
+    Priority: ?next= parameter > Referer header (if same-origin) > /
+    """
+    # First try the explicit next parameter
+    if validated := validate_redirect(next_param):
+        return validated
+
+    # Then try the Referer header if same-origin
+    config = get_config()
+    referer = request.headers.get("referer")
+    if _is_same_origin(referer, config.app_url):
+        # Extract just the path from referer
+        parsed = urlparse(referer)
+        path = parsed.path
+        if parsed.query:
+            path += f"?{parsed.query}"
+        if validated := validate_redirect(path):
+            return validated
+
+    # Default to root
+    return "/"
+
+
+def _get_session_data(request: Request) -> SessionData | None:
+    """Get session data from request cookie."""
+    raw_session = decrypt_session(request.cookies.get(SESSION_COOKIE_NAME))
+    if not raw_session:
+        return None
+    try:
+        return SessionData.from_dict(raw_session)
+    except (KeyError, TypeError):
+        return None
+
+
+def _fetch_delegated_token(principal_tokens: TokenSet, target_user_id: str) -> TokenSet:
+    """Fetch a delegated token for the target user using principal credentials."""
+    config = get_config()
+
+    response = httpx.post(
+        f"{DEFAULT_URL}/api/v1/oauth/delegated-token",
+        headers={"Authorization": f"Bearer {principal_tokens.access_token}"},
+        json={"sub": target_user_id},
+    )
+
+    if response.status_code == 403:
+        raise HTTPException(status_code=403, detail="You don't have access to this user")
+    if response.status_code == 404:
+        raise HTTPException(status_code=404, detail="User not found")
+
+    response.raise_for_status()
+    tokens = response.json()
+
+    return TokenSet(
+        access_token=tokens["access_token"],
+        refresh_token=tokens["refresh_token"],
+        user_id=target_user_id,
+    )
+
+
 def create_state(next_url: str | None) -> str:
     """Create an OAuth state value with nonce and optional redirect."""
     nonce = secrets.token_urlsafe(32)
@@ -160,6 +244,57 @@ def create_router() -> APIRouter:
         clear_session_cookie(response)
         return response
 
+    @router.post("/select-user/{user_id}")
+    def select_user(request: Request, user_id: str, next: str | None = None) -> Response:
+        """Switch to viewing as another user.
+
+        Fetches a delegated token for the target user and stores it in the session.
+        Redirects to Referer (if same-origin), ?next= parameter, or /.
+        """
+        session = _get_session_data(request)
+        if not session:
+            raise HTTPException(status_code=401, detail="Not authenticated")
+
+        # Fetch delegated token for the target user
+        try:
+            delegated_tokens = _fetch_delegated_token(session.principal, user_id)
+        except httpx.HTTPStatusError as e:
+            logger.warning("Failed to fetch delegated token for user %s: %s", user_id, e)
+            raise HTTPException(status_code=403, detail="You don't have access to this user")
+
+        # Update session with delegated tokens
+        updated_session = SessionData(
+            principal=session.principal,
+            delegated=delegated_tokens,
+        )
+
+        redirect_url = _get_redirect_url(request, next)
+        response = RedirectResponse(url=redirect_url, status_code=303)
+        set_session_cookie(response, updated_session.to_dict())
+        return response
+
+    @router.post("/select-self")
+    def select_self(request: Request, next: str | None = None) -> Response:
+        """Switch back to viewing as yourself (clear delegation).
+
+        Removes the delegated tokens from the session.
+        Redirects to Referer (if same-origin), ?next= parameter, or /.
+        """
+        session = _get_session_data(request)
+        if not session:
+            raise HTTPException(status_code=401, detail="Not authenticated")
+
+        # Clear delegation
+        updated_session = SessionData(
+            principal=session.principal,
+            delegated=None,
+        )
+
+        redirect_url = _get_redirect_url(request, next)
+        response = RedirectResponse(url=redirect_url, status_code=303)
+        set_session_cookie(response, updated_session.to_dict())
+        return response
+
     return router
 
 

{sweatstack-0.60.0.dist-info → sweatstack-0.61.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sweatstack
-Version: 0.60.0
+Version: 0.61.0
 Summary: The official Python client for SweatStack
 Author-email: Aart Goossens <aart@gssns.io>
 Requires-Python: >=3.9

{sweatstack-0.60.0.dist-info → sweatstack-0.61.0.dist-info}/RECORD

@@ -11,12 +11,13 @@ sweatstack/streamlit.py,sha256=wnabWhife9eMAdkECPjRKkzE82KZoi_H8YzucZl_m9s,19604
 sweatstack/sweatshell.py,sha256=MYLNcWbOdceqKJ3S0Pe8dwHXEeYsGJNjQoYUXpMTftA,333
 sweatstack/utils.py,sha256=AwHRdC1ziOZ5o9RBIB21Uxm-DoClVRAJSVvgsmSmvps,1801
 sweatstack/Sweat Stack examples/Getting started.ipynb,sha256=k2hiSffWecoQ0VxjdpDcgFzBXDQiYEebhnAYlu8cgX8,6335204
-sweatstack/fastapi/__init__.py,sha256=4_a6oqapT8Pv0sdt6OmuTA_vo4qFSiyXjN5WMLnl0rs,971
-sweatstack/fastapi/config.py,sha256=9u_XXGpX2XdOJO8G2sL_Cx4L_hYUzktozS2MkIs7Fwk,6304
-sweatstack/fastapi/dependencies.py,sha256=K9nuSV5Vduu4hoN94B8rj6UKtUBu9uKtSwEmECDG9vM,5060
-sweatstack/fastapi/routes.py,sha256=ZyaowLYXlOM6a74Cog5uSzPKHNTBvOpIBruaJVzhKjE,5339
+sweatstack/fastapi/__init__.py,sha256=J20u-R3ABLP0vGLl3m_H76nTvpoMHtpKpyH8vufb9kM,2465
+sweatstack/fastapi/config.py,sha256=S9Y5G5YprSugICtkCdVEUBwdbGsg2MuzdPx8QJaP8XA,7850
+sweatstack/fastapi/dependencies.py,sha256=6QrWCcYJJXI0-Tn2A4hKimVMCa45rRUAu-gijtgAq4k,8739
+sweatstack/fastapi/models.py,sha256=2VNKITN7LKacQxxVgYJjDaZ6Xq2eYBtvkQbq7H6bLlY,3386
+sweatstack/fastapi/routes.py,sha256=Y-g8DMM2gG_8ETnLN7ZfUqBT8AkwIG9WFbEqJtyyKcM,10058
 sweatstack/fastapi/session.py,sha256=BtRPCmIEaToJPwFyZ0fqWGlmnDHuWKy8nri9dJrPXaA,2717
-sweatstack-0.60.0.dist-info/METADATA,sha256=XJq9khIsRFJDUVGLB9Vv_qwRutrIHlU4QwHRsLQKdeU,994
-sweatstack-0.60.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-sweatstack-0.60.0.dist-info/entry_points.txt,sha256=kCzOUQI3dqbTpEYqtgYDeiKFaqaA7BMlV6D24BMzCFU,208
-sweatstack-0.60.0.dist-info/RECORD,,
+sweatstack-0.61.0.dist-info/METADATA,sha256=RGfVVMy3zO08wiJw98gF-9IW_8gjuYsJ3Kg58BAJyi4,994
+sweatstack-0.61.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+sweatstack-0.61.0.dist-info/entry_points.txt,sha256=kCzOUQI3dqbTpEYqtgYDeiKFaqaA7BMlV6D24BMzCFU,208
+sweatstack-0.61.0.dist-info/RECORD,,