django-oura 0.1.0__tar.gz

django_oura-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,51 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+    tags: ["v*"]
+  pull_request:
+    branches: [main]
+  workflow_dispatch:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
+    steps:
+      - uses: actions/checkout@v7
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v8.2.0
+
+      - name: Install Python ${{ matrix.python-version }}
+        run: uv python install ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: uv sync --python ${{ matrix.python-version }} --group dev
+
+      - name: Run tests
+        run: uv run pytest tests/ -v
+
+  publish:
+    needs: test
+    runs-on: ubuntu-latest
+    if: startsWith(github.ref, 'refs/tags/v')
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/checkout@v7
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v8.2.0
+
+      - name: Build package
+        run: uv build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          skip-existing: true

django_oura-0.1.0/.github/workflows/pre-commit.yml

@@ -0,0 +1,22 @@
+name: Pre-commit
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  pre-commit:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v8.2.0
+
+      - name: Install Python
+        run: uv python install
+
+      - name: Run pre-commit
+        uses: pre-commit/action@v3.0.1

django_oura-0.1.0/.gitignore

@@ -0,0 +1,63 @@
+# Byte-compiled / optimized
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# uv / virtualenv
+.venv/
+venv/
+env/
+
+# Testing / coverage
+.pytest_cache/
+.coverage
+.coverage.*
+htmlcov/
+.tox/
+.nox/
+coverage.xml
+*.cover
+
+# Type checkers / linters
+.mypy_cache/
+.ruff_cache/
+.pyre/
+.pytype/
+
+# Django
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+media/
+staticfiles/
+
+# Local env vars (never commit — they hold OAuth secrets)
+.env
+.env.*
+!.env.example
+
+# Editors / OS
+.idea/
+.vscode/
+*.swp
+.DS_Store

django_oura-0.1.0/.pre-commit-config.yaml

@@ -0,0 +1,18 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v6.0.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-yaml
+      - id: check-toml
+      - id: check-added-large-files
+      - id: check-merge-conflict
+      - id: debug-statements
+
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.15.18
+    hooks:
+      - id: ruff
+        args: [--fix]
+      - id: ruff-format

django_oura-0.1.0/.python-version

@@ -0,0 +1 @@
+3.13

django_oura-0.1.0/CLAUDE.md

@@ -0,0 +1,85 @@
+# Notes for Claude (and human contributors)
+
+This project is a reusable Django library — small, focused, with a real
+shipping cadence to PyPI. Slice-sized changes; commit messages with the
+"why"; tests for every behavior; live calibration over docs guessing.
+
+It is a sibling of `django-health/django-google-health` and
+`django-health/django-garmin` and deliberately mirrors their layout,
+pyproject/CI/pre-commit setup, and OAuth/client/ingest module boundaries.
+When in doubt about a pattern, check what those repos do.
+
+## Oura API ground truth
+
+The Oura V2 OpenAPI spec (`https://cloud.ouraring.com/v2/docs`, spec JSON at
+`/v2/static/json/openapi-<version>.json`) is ground truth for routes and
+payload shapes; `docs/oura/` summarizes it plus the authentication and
+webhook guides. Payload shapes in `oura/ingest.py` and the test fixtures were
+written against spec version 1.35 and have NOT yet been calibrated against a
+live ring — when live credentials are available, verify against real
+payloads and promote findings into code comments + tests, not just commit
+messages.
+
+Live-calibration entry point: run the demo (`README.md` → "Try it on your own
+data"), then pull the access token from `db.sqlite3` and hit
+`https://api.ouraring.com/v2/usercollection/...` directly with `httpx` before
+guessing at code fixes.
+
+Things Oura does differently from its siblings (don't "fix" them):
+
+- Users consent PER SCOPE on the authorization page; the granted set can be
+  narrower than requested and only shows up on the token response.
+- Refresh tokens are SINGLE-USE and rotate on every refresh — both tokens
+  persist together (like Garmin, unlike Google).
+- Document routes filter by the calendar day the data belongs to, in the
+  user's LOCAL timezone (`start_date`/`end_date`, inclusive) — not upload
+  time. `heartrate` is the odd one out: a time series filtered by
+  `start_datetime`/`end_datetime`.
+- Timestamps are localized (`2026-07-04T23:12:00-04:00`). Never feed them to
+  `RecordInput`'s string coercion — it assumes naive-UTC. `oura.ingest._utc`
+  parses and converts properly.
+- Webhook subscriptions are app-level (`x-client-id`/`x-client-secret`
+  headers), one per (event_type, data_type) pair, with a synchronous GET
+  challenge at creation and periodic expiry/renewal.
+- Webhook notifications carry only ids — the document is fetched with the
+  matching user's token. The HMAC signature scheme in
+  `oura.webhooks.compute_signature` (HMAC-SHA256 over `timestamp + body`,
+  uppercase hex) is from Oura's docs example and is a prime candidate for
+  live calibration.
+- Sleep stages come as a `sleep_phase_5_min` digit string, not intervals;
+  the mapper collapses runs and clamps the tail to `bedtime_end`.
+
+## Upstream contributions to django-healthdatamodel
+
+The sister repo `django-health/django-healthdatamodel` is where the storage
+layer lives. When a change there unblocks this project, you have end-to-end
+release autonomy as long as CI is green:
+
+1. Open the PR.
+2. Wait for CI green.
+3. Bump version in `pyproject.toml` (minor for additive, patch for fix).
+4. Squash-merge.
+5. Tag `v<X>` on `main`, push the tag — triggers PyPI publish via OIDC.
+6. Bump the floor in this repo's `pyproject.toml`, swap any local stopgaps
+   for the upstream API, commit + push.
+
+Both repos publish to PyPI via trusted publishing — no manual upload.
+Heads-up from the v0.7.0 release: `makemigrations` output is not
+ruff-formatted — run `pre-commit run --all-files` before committing a
+generated migration or the Pre-commit workflow goes red.
+
+## Out of scope for this project
+
+- **Token encryption at rest.** Production deployment uses Postgres with
+  encryption-at-rest at the storage layer. Don't add Fernet /
+  django-cryptography fields to `OuraConnection`.
+- **Signup view in the demo.** `createsuperuser` is the way. The demo exists
+  so the maintainer can test against their own Oura account; it isn't a
+  hosted SaaS shell.
+- **Oura-specific scores (readiness, resilience, stress).** They have no
+  HealthKit-schema equivalent in healthdatamodel today. If they're ever
+  wanted, that's an upstream schema conversation first, not a local hack.
+- **The legacy wellrider Oura V1 code.** It was removed upstream
+  (massmutual wellrider PR #1157) and targeted the sunset V1 API; it is not
+  a compatibility target. Its one useful legacy: basal calories = `total −
+  active`, which this package preserves.

django_oura-0.1.0/PKG-INFO

@@ -0,0 +1,193 @@
+Metadata-Version: 2.4
+Name: django-oura
+Version: 0.1.0
+Summary: A Django app for the Oura API v2, backed by django-healthdatamodel.
+Project-URL: Homepage, https://github.com/django-health/django-oura
+Project-URL: Repository, https://github.com/django-health/django-oura
+Project-URL: Issues, https://github.com/django-health/django-oura/issues
+Author-email: Andy Reagan <andy@andyreagan.com>
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 5.0
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Requires-Python: >=3.10
+Requires-Dist: django
+Requires-Dist: django-healthdatamodel>=0.7.0
+Requires-Dist: httpx
+Requires-Dist: pydantic>=2
+Requires-Dist: python-dateutil
+Description-Content-Type: text/markdown
+
+# django-oura
+
+[![CI](https://github.com/django-health/django-oura/actions/workflows/ci.yml/badge.svg)](https://github.com/django-health/django-oura/actions/workflows/ci.yml)
+
+A reusable Django app for the [Oura API v2](https://cloud.ouraring.com/v2/docs). Handles Oura's OAuth 2.0 flow, fetches documents from `api.ouraring.com/v2/usercollection`, receives webhook notifications, and persists everything through [`django-healthdatamodel`](https://github.com/django-health/django-healthdatamodel) so the same storage and query layer serves Apple Health, Fitbit, Google Health, Garmin, and Oura side-by-side.
+
+> The Oura V1 API is sunset, and personal access tokens were retired in December 2025 — this package speaks only V2 with OAuth2. API applications are limited to 10 users before requiring approval from Oura.
+
+## Install
+
+```
+pip install django-oura
+```
+
+Add both this app and `django-healthdatamodel` to `INSTALLED_APPS`, then run migrations:
+
+```python
+INSTALLED_APPS = [
+    ...
+    "healthdatamodel",
+    "oura",
+]
+```
+
+```
+python manage.py migrate
+```
+
+The model uses `settings.AUTH_USER_MODEL` so it works with any custom user model.
+
+## Configuration
+
+```python
+OURA_CLIENT_ID = "..."       # from https://cloud.ouraring.com/oauth/applications
+OURA_CLIENT_SECRET = "..."
+OURA_REDIRECT_URI = "https://your-app.example.com/oura/callback/"
+
+# Optional:
+OURA_SCOPES = ["daily", "heartrate", "workout", "spo2"]  # the default set
+OURA_CONNECT_SUCCESS_URL = "/"                            # default "/admin/"
+OURA_WEBHOOK_VERIFICATION_TOKEN = "..."                   # only for webhooks
+```
+
+Register the redirect URI on the Oura application — the token exchange fails on any mismatch. Users consent **per scope** on Oura's authorization page, so the granted set may be narrower than requested; whatever was actually granted is stored on `OuraConnection.scopes`.
+
+## URLs
+
+```python
+urlpatterns = [
+    ...
+    path("oura/", include("oura.urls")),
+]
+```
+
+This mounts:
+
+- `oura/connect/` — start the OAuth flow (login required)
+- `oura/callback/` — the redirect URI target
+- `oura/disconnect/` — POST; revokes the token at Oura and marks the connection revoked
+- `oura/notifications/` — webhook receiver (GET verification challenge + POST events)
+
+Mobile clients that run the OAuth dance themselves can POST the resulting token dict to a project-local endpoint that calls `oura.oauth.ingest_tokens`.
+
+## Getting data
+
+Oura's recommended architecture is **one historical pull when a user connects, then webhooks** — properly implemented, webhook consumers don't hit the API's 5000-requests-per-5-minutes rate limit.
+
+**Pull.** `oura.ingest.sync_user(connection, start=..., end=...)` fetches and ingests the configured data types. Document routes filter by the calendar day the data belongs to (in the user's local timezone), so re-syncing a window picks up revisions to those days.
+
+```
+python manage.py sync_oura                    # last day, all active connections
+python manage.py sync_oura --user alice --days 30
+python manage.py sync_oura --data-type daily_activity --data-type sleep
+```
+
+**Webhooks.** Subscriptions are app-level, one per `(event_type, data_type)` pair, and Oura verifies your endpoint with a GET challenge at subscription time — `oura/notifications/` answers it using `OURA_WEBHOOK_VERIFICATION_TOKEN`. Create them once the endpoint is live:
+
+```
+python manage.py create_oura_webhook_subscription \
+    --callback-url https://api.example.com/oura/notifications/ \
+    --verification-token "$OURA_WEBHOOK_VERIFICATION_TOKEN" \
+    --data-type daily_activity --data-type sleep --data-type workout
+python manage.py list_oura_webhook_subscriptions
+python manage.py delete_oura_webhook_subscription <id>
+```
+
+Then connect a signal handler to drive ingest:
+
+```python
+from django.dispatch import receiver
+from oura.signals import notification_received
+from oura.webhooks import process_notification
+
+@receiver(notification_received)
+def on_notification(sender, payload, **kwargs):
+    process_notification(payload)  # or hand off to celery / a queue
+```
+
+Notifications carry `{event_type, data_type, object_id, user_id}`; `process_notification` routes to a user by Oura's stable `user_id`, fetches the referenced document with that user's credentials, and ingests it. The receiver view enforces Oura's `x-oura-signature` HMAC before emitting the signal (set `OURA_WEBHOOK_REQUIRE_SIGNATURE = False` to accept unsigned POSTs). Oura expects a 2xx within 10 seconds — hand off to a queue if your processing is heavy. Subscriptions expire; renew with `oura.webhooks.renew_subscription`.
+
+## What gets stored
+
+This app does **not** define `Record` / `Workout` tables — those live in `django-healthdatamodel`. The `oura.ingest` module maps Oura documents to `healthdatamodel` inputs and persists them with `source="oura"`:
+
+| Oura data type | healthdatamodel records |
+| --- | --- |
+| `daily_activity` | steps, active calories, basal calories (total − active), equivalent walking distance |
+| `sleep` | one sleep-stage record per `sleep_phase_5_min` run (deep/light/REM/awake) |
+| `daily_spo2` | daily SpO2 average |
+| `heartrate` | one heart-rate sample per 5-minute increment |
+| `workout` | one `Workout` per workout |
+
+Oura-specific scores (readiness, sleep score, resilience, stress) have no HealthKit-schema equivalent and are not ingested yet.
+
+The only model defined here is `OuraConnection`: per-user OAuth tokens (Oura refresh tokens are single-use — both tokens are rewritten together on every refresh), granted scopes, connection status, and last sync timestamp.
+
+## Try it on your own data
+
+The repo includes a runnable demo Django project at `demo/`.
+
+### 1. Register an Oura API application (one-time)
+
+Create one at [cloud.ouraring.com/oauth/applications](https://cloud.ouraring.com/oauth/applications) and register the redirect URI `http://localhost:8000/oura/callback/` (exact match, trailing slash included). Unapproved applications are limited to 10 users — fine for the demo.
+
+### 2. Run the demo
+
+```
+uv sync
+uv run python manage.py migrate
+uv run python manage.py createsuperuser
+export OURA_CLIENT_ID=...
+export OURA_CLIENT_SECRET=...
+uv run python manage.py runserver
+```
+
+Open <http://localhost:8000/>, sign in with the superuser you just created, then:
+
+- Click **Connect Oura** → consent on Oura (pick your scopes) → land back on the homepage with an `OuraConnection` saved for your user.
+- Open the Oura app on your phone so your ring syncs (sleep data only reaches Oura's cloud that way), then pick a window and click **Sync now**.
+- Browse the resulting rows at `/admin/healthdatamodel/record/` (and `.../workout/`).
+
+Or drive sync from the terminal:
+
+```
+uv run python manage.py sync_oura --user <your-username> --days 30
+```
+
+## Documentation
+
+Summaries of the Oura API docs live under `docs/oura/` so they're grep-able offline:
+
+- `authentication.md` — OAuth2 endpoints, scopes, token lifetimes, revocation
+- `api.md` — the v2 usercollection routes, params, pagination, payload shapes
+- `webhooks.md` — subscription API, verification challenge, signatures, retries
+
+## Development
+
+```
+uv sync --group dev
+uv run pytest tests/ -v
+uv run pre-commit run --all-files
+```

django_oura-0.1.0/README.md

@@ -0,0 +1,162 @@
+# django-oura
+
+[![CI](https://github.com/django-health/django-oura/actions/workflows/ci.yml/badge.svg)](https://github.com/django-health/django-oura/actions/workflows/ci.yml)
+
+A reusable Django app for the [Oura API v2](https://cloud.ouraring.com/v2/docs). Handles Oura's OAuth 2.0 flow, fetches documents from `api.ouraring.com/v2/usercollection`, receives webhook notifications, and persists everything through [`django-healthdatamodel`](https://github.com/django-health/django-healthdatamodel) so the same storage and query layer serves Apple Health, Fitbit, Google Health, Garmin, and Oura side-by-side.
+
+> The Oura V1 API is sunset, and personal access tokens were retired in December 2025 — this package speaks only V2 with OAuth2. API applications are limited to 10 users before requiring approval from Oura.
+
+## Install
+
+```
+pip install django-oura
+```
+
+Add both this app and `django-healthdatamodel` to `INSTALLED_APPS`, then run migrations:
+
+```python
+INSTALLED_APPS = [
+    ...
+    "healthdatamodel",
+    "oura",
+]
+```
+
+```
+python manage.py migrate
+```
+
+The model uses `settings.AUTH_USER_MODEL` so it works with any custom user model.
+
+## Configuration
+
+```python
+OURA_CLIENT_ID = "..."       # from https://cloud.ouraring.com/oauth/applications
+OURA_CLIENT_SECRET = "..."
+OURA_REDIRECT_URI = "https://your-app.example.com/oura/callback/"
+
+# Optional:
+OURA_SCOPES = ["daily", "heartrate", "workout", "spo2"]  # the default set
+OURA_CONNECT_SUCCESS_URL = "/"                            # default "/admin/"
+OURA_WEBHOOK_VERIFICATION_TOKEN = "..."                   # only for webhooks
+```
+
+Register the redirect URI on the Oura application — the token exchange fails on any mismatch. Users consent **per scope** on Oura's authorization page, so the granted set may be narrower than requested; whatever was actually granted is stored on `OuraConnection.scopes`.
+
+## URLs
+
+```python
+urlpatterns = [
+    ...
+    path("oura/", include("oura.urls")),
+]
+```
+
+This mounts:
+
+- `oura/connect/` — start the OAuth flow (login required)
+- `oura/callback/` — the redirect URI target
+- `oura/disconnect/` — POST; revokes the token at Oura and marks the connection revoked
+- `oura/notifications/` — webhook receiver (GET verification challenge + POST events)
+
+Mobile clients that run the OAuth dance themselves can POST the resulting token dict to a project-local endpoint that calls `oura.oauth.ingest_tokens`.
+
+## Getting data
+
+Oura's recommended architecture is **one historical pull when a user connects, then webhooks** — properly implemented, webhook consumers don't hit the API's 5000-requests-per-5-minutes rate limit.
+
+**Pull.** `oura.ingest.sync_user(connection, start=..., end=...)` fetches and ingests the configured data types. Document routes filter by the calendar day the data belongs to (in the user's local timezone), so re-syncing a window picks up revisions to those days.
+
+```
+python manage.py sync_oura                    # last day, all active connections
+python manage.py sync_oura --user alice --days 30
+python manage.py sync_oura --data-type daily_activity --data-type sleep
+```
+
+**Webhooks.** Subscriptions are app-level, one per `(event_type, data_type)` pair, and Oura verifies your endpoint with a GET challenge at subscription time — `oura/notifications/` answers it using `OURA_WEBHOOK_VERIFICATION_TOKEN`. Create them once the endpoint is live:
+
+```
+python manage.py create_oura_webhook_subscription \
+    --callback-url https://api.example.com/oura/notifications/ \
+    --verification-token "$OURA_WEBHOOK_VERIFICATION_TOKEN" \
+    --data-type daily_activity --data-type sleep --data-type workout
+python manage.py list_oura_webhook_subscriptions
+python manage.py delete_oura_webhook_subscription <id>
+```
+
+Then connect a signal handler to drive ingest:
+
+```python
+from django.dispatch import receiver
+from oura.signals import notification_received
+from oura.webhooks import process_notification
+
+@receiver(notification_received)
+def on_notification(sender, payload, **kwargs):
+    process_notification(payload)  # or hand off to celery / a queue
+```
+
+Notifications carry `{event_type, data_type, object_id, user_id}`; `process_notification` routes to a user by Oura's stable `user_id`, fetches the referenced document with that user's credentials, and ingests it. The receiver view enforces Oura's `x-oura-signature` HMAC before emitting the signal (set `OURA_WEBHOOK_REQUIRE_SIGNATURE = False` to accept unsigned POSTs). Oura expects a 2xx within 10 seconds — hand off to a queue if your processing is heavy. Subscriptions expire; renew with `oura.webhooks.renew_subscription`.
+
+## What gets stored
+
+This app does **not** define `Record` / `Workout` tables — those live in `django-healthdatamodel`. The `oura.ingest` module maps Oura documents to `healthdatamodel` inputs and persists them with `source="oura"`:
+
+| Oura data type | healthdatamodel records |
+| --- | --- |
+| `daily_activity` | steps, active calories, basal calories (total − active), equivalent walking distance |
+| `sleep` | one sleep-stage record per `sleep_phase_5_min` run (deep/light/REM/awake) |
+| `daily_spo2` | daily SpO2 average |
+| `heartrate` | one heart-rate sample per 5-minute increment |
+| `workout` | one `Workout` per workout |
+
+Oura-specific scores (readiness, sleep score, resilience, stress) have no HealthKit-schema equivalent and are not ingested yet.
+
+The only model defined here is `OuraConnection`: per-user OAuth tokens (Oura refresh tokens are single-use — both tokens are rewritten together on every refresh), granted scopes, connection status, and last sync timestamp.
+
+## Try it on your own data
+
+The repo includes a runnable demo Django project at `demo/`.
+
+### 1. Register an Oura API application (one-time)
+
+Create one at [cloud.ouraring.com/oauth/applications](https://cloud.ouraring.com/oauth/applications) and register the redirect URI `http://localhost:8000/oura/callback/` (exact match, trailing slash included). Unapproved applications are limited to 10 users — fine for the demo.
+
+### 2. Run the demo
+
+```
+uv sync
+uv run python manage.py migrate
+uv run python manage.py createsuperuser
+export OURA_CLIENT_ID=...
+export OURA_CLIENT_SECRET=...
+uv run python manage.py runserver
+```
+
+Open <http://localhost:8000/>, sign in with the superuser you just created, then:
+
+- Click **Connect Oura** → consent on Oura (pick your scopes) → land back on the homepage with an `OuraConnection` saved for your user.
+- Open the Oura app on your phone so your ring syncs (sleep data only reaches Oura's cloud that way), then pick a window and click **Sync now**.
+- Browse the resulting rows at `/admin/healthdatamodel/record/` (and `.../workout/`).
+
+Or drive sync from the terminal:
+
+```
+uv run python manage.py sync_oura --user <your-username> --days 30
+```
+
+## Documentation
+
+Summaries of the Oura API docs live under `docs/oura/` so they're grep-able offline:
+
+- `authentication.md` — OAuth2 endpoints, scopes, token lifetimes, revocation
+- `api.md` — the v2 usercollection routes, params, pagination, payload shapes
+- `webhooks.md` — subscription API, verification challenge, signatures, retries
+
+## Development
+
+```
+uv sync --group dev
+uv run pytest tests/ -v
+uv run pre-commit run --all-files
+```

django_oura-0.1.0/demo/admin.py

@@ -0,0 +1,30 @@
+"""Wire healthdatamodel's unregistered admin classes into the demo project.
+
+The upstream package exposes ``RecordAdmin`` / ``WorkoutAdmin`` /
+``WearableConnectionAdmin`` as classes but doesn't call ``admin.site.register``
+itself — that lets each consumer decide whether to expose these in their own
+admin. The demo registers them so you can browse synced data at
+``/admin/healthdatamodel/record/`` and friends.
+"""
+
+from django.contrib import admin
+from healthdatamodel.admin import (
+    DataSourceRankingAdmin,
+    RecordAdmin,
+    WearableConnectionAdmin,
+    WorkoutAdmin,
+    WorkoutMetadataEntryAdmin,
+)
+from healthdatamodel.models import (
+    DataSourceRanking,
+    Record,
+    WearableConnection,
+    Workout,
+    WorkoutMetadataEntry,
+)
+
+admin.site.register(Record, RecordAdmin)
+admin.site.register(Workout, WorkoutAdmin)
+admin.site.register(WorkoutMetadataEntry, WorkoutMetadataEntryAdmin)
+admin.site.register(WearableConnection, WearableConnectionAdmin)
+admin.site.register(DataSourceRanking, DataSourceRankingAdmin)