swl 5.0.0__tar.gz

swl-5.0.0/.flake8

@@ -0,0 +1,23 @@
+[flake8]
+exclude =
+    # No need to traverse our git directory
+    .git,
+    # There's no value in checking cache directories
+    __pycache__,
+    # This contains our built documentation
+    build,
+    # This contains builds of flake8 that we don't want to check
+    dist,
+    # This contains the virtual environment
+    env,
+extend-ignore =
+    # E266 too many leading '#' for block comment
+    E266,
+    # docstring
+    D10
+per-file-ignores =
+    swl/*_test.py:F401,F811
+    # Ignore unused imports in __init__
+    swl/*/__init__.py:F401,F403
+    swl/__init__.py:F401,F403
+max-line-length = 90

swl-5.0.0/.github/workflows/publish.yml

@@ -0,0 +1,39 @@
+name: Publish to PyPI
+
+# Publishes when a MAJOR.MINOR.PATCH tag (e.g. 0.6.4) is pushed. The tag
+# becomes the package version via setuptools_scm.
+on:
+  push:
+    tags: ["[0-9]+.[0-9]+.[0-9]+"]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.13"
+      - run: pip install build
+      - run: python -m build
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/project/swl/
+    permissions:
+      id-token: write  # PyPI trusted publishing, no API token needed
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1

swl-5.0.0/.github/workflows/test.yml

@@ -0,0 +1,22 @@
+name: Tests
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.11", "3.12", "3.13", "3.14"]
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          fetch-depth: 0  # setuptools_scm needs the tags
+      - uses: actions/setup-python@v6
+        with:
+          python-version: ${{ matrix.python-version }}
+      - run: pip install -e . -e example/
+      - run: python -m pytest swl example/swl_tasks

swl-5.0.0/.gitignore

@@ -0,0 +1,8 @@
+env/
+*.egg-info/
+dist/
+build/
+swl-tasks-data/
+*.swp
+.DS_store
+doc/swl-reference.pdf

swl-5.0.0/CHANGELOG.md

@@ -0,0 +1,90 @@
+# Changelog
+
+## 5.0.0 (2026-10-29)
+
+SWL moves its browser side to [htmx 4](https://four.htmx.org). The Python API (actions,
+`register()`, `swl.success()` / `swl.fail()`) stays the same, but templates and JavaScript have
+to be converted: `doc/htmx-migration.md` lists every change.
+
+SWL is now released under the MIT License (it was GPL v2 or later), and is published on
+[GitHub](https://github.com/seecr/swl) and [PyPI](https://pypi.org/project/swl/).
+
+### Breaking
+
+- **htmx instead of SWL's own jQuery code.**
+  - The `data-swl-*` attributes are replaced by `hx-*` attributes; `data-swl-validate` and
+    `data-swl-on-changed` stay. See the table in `doc/htmx-migration.md`.
+  - jQuery is no longer loaded.
+  - `rehydrate.js` is gone, and `swl.js` no longer exports `hydrate`, `start_hydrating`,
+    `rehydrate_placeholder`, `arguments_from_elem` and `swl_arguments_from_elem`.
+- **The response is HTML plus headers instead of JSON.**
+  - Hydrated content arrives as `<hx-partial>` elements, and the other instructions as an
+    `HX-Trigger` header.
+  - An empty response is `204`; `swl.fail()` is `422`.
+  - Tests use `swl.test_utils.assert_success()` and `assert_fail()` instead of
+    `response.json()`.
+- **`hydrate()` data can no longer be an action url** that is fetched next. Return a placeholder
+  in the HTML instead.
+- **Placeholders post only their own values** (`hx-vals` and `hx-include`), not the fields inside
+  or around them.
+- **The modal, message dialog, toast and context menu are native HTML.** The modal and dialog
+  are `<dialog>` elements; the toast and context menu are popovers. They no longer need
+  Bootstrap's JavaScript.
+  - `swl/modal-content.j2` uses `swl-modal-*` classes instead of Bootstrap's `modal-header` /
+    `modal-body`.
+  - JavaScript that listened to `shown.bs.modal` / `hidden.bs.modal` uses `swl-modal-shown` /
+    the dialog's `close` event.
+  - Put context menu items in a `<div class="swl-menu">`.
+  - A page with its own Bootstrap modal markup (`<div id="swl-modal" class="modal">`) still
+    works.
+- **Web resources come from cdn.jsdelivr.net**, with integrity hashes: htmx 4.0.0, Bootstrap
+  5.3.8 (was 5.3.0), Bootstrap Icons 1.13.1 (was 1.11.3), Tabler 1.6.1 and Bulma 1.0.4.
+  - `urls.cdn` now defaults to `https://cdn.jsdelivr.net` (was `https://cdn.seecr.nl`).
+  - `swl/resources/default-web-resources.json` is renamed to `bootstrap-web-resources.json`.
+- **The account and user screens have a new layout.** They have captions above the fields, an
+  avatar, and toasts after a change. An application that styled their old Bootstrap markup should
+  check them.
+
+### Added
+
+- **Choice of CSS framework**: `ui.framework` is `"bootstrap"` (the default), `"tabler"`,
+  `"bulma"` or `"swl"`.
+  - `"swl"` uses SWL's own `swl-base.css`, with no framework at all.
+  - The choice sets the web resources, and `SWL.ui`: CSS classes for inputs, buttons and tables
+    in that framework.
+  - `paths.resources` still replaces the resources with your own file.
+- **Theme variables** (`--swl-accent`, `--swl-bg`, ...) for SWL's own parts. They follow
+  Bootstrap's, Tabler's or Bulma's colours.
+- **Layout classes in `swl.css`** that work with every framework: `swl-container`, `swl-nav`,
+  `swl-columns`, `swl-card`, `swl-tabs`, `swl-stack`, `swl-row`, `swl-field`, `swl-list`,
+  `swl-link`, `swl-menu` and more.
+- **Light and dark colours**: `/static/swl/theme.js` with `swl_theme.set("light" | "dark" |
+  "auto")`, for every framework.
+- **`FrameworkCookieMiddleware`**: lets a visitor choose the framework with a cookie, for demos
+  and style guides.
+- **`placeholder()` macro** (`swl/placeholder.j2`) for elements that load and reload
+  themselves.
+- **`swl.success().trigger(event, **detail)`**: fire your own JavaScript event.
+- **`data-swl-close`** on a button closes the modal. `swl/modal-content.j2` has an optional
+  `modal_footer` block.
+- **Deep links.**
+  - `kickstart` now waits until the page's placeholders have loaded, so it can rebuild nested
+    screens.
+  - Its `kwargs` may be a dict and are escaped safely.
+  - `doc/reference.md` explains deep links: `set_url` plus a page route.
+- **An example application** (`example/`, a task list) with a guided walkthrough. Run it with
+  `--framework swl | bootstrap | tabler | bulma`.
+- **Documentation**: `README.md`, `doc/reference.md` (with debugging and troubleshooting) and
+  `doc/htmx-migration.md`.
+
+### Fixed
+
+- Failing requests (HTTP errors, network errors) are reported in SWL's dialog, never swapped into
+  the page. A request that ends on a redirect, for example to the login page after the session
+  expired, becomes a page load.
+- A function called by name (`call`, `data-swl-validate`, the modal's `call`) that is missing or
+  fails is reported, and does not stop the rest of the response.
+- The context menu posts the element's values and the click position correctly.
+- `open_modal(call=...)` runs the function once per opening.
+- A second toast while the first is still showing no longer causes an error.
+- `SWL.globals` referred to an attribute that does not exist.

swl-5.0.0/CLAUDE.md

@@ -0,0 +1,72 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+# SWL (Seecr Web Lib)
+
+Python library for interactive web apps: Starlette on the server, Jinja templates, htmx 4 in the
+browser. MIT license. Maintained by Seecr (Johan Jonkers, Thijs Janssen).
+
+## State of the project
+
+- The browser side is htmx 4 (it was jQuery with `data-swl-*` attributes up to 4.3.0; a breaking
+  change). `doc/htmx-migration.md` describes converting an application.
+- SWL's modal/dialog are native `<dialog>`, toast and context menu are popovers, styled by
+  `swl.css` with `--swl-*` variables; SWL needs no framework JavaScript. `"ui.framework"`:
+  "bootstrap" (default), "tabler" (Bootstrap-based), "bulma" or "swl" (SWL's own `swl-base.css`,
+  no framework) picks the web resources and `SWL.ui` (classes for inputs/buttons, see
+  `swl/frameworks.py`). Layout classes (swl-nav, swl-columns, swl-card, swl-tabs) live in swl.css.
+  The example runs with each: `python -m swl_tasks --framework bulma`.
+  Pico CSS was considered and rejected (no longer maintained).
+
+## Where things are
+
+- `swl/swl.py`, `swl/actions.py`: app setup, action registration (`__actions__`, `register(name)`
+  gives `/action/<md5>` urls; actions need a logged-in user unless `authenticated=False`).
+- `swl/responses.py`: `swl.success()` / `swl.fail()` builder. Output = HTML with `<hx-partial>`
+  elements (from `hydrate`) + an `HX-Trigger` header with SWL events (`swl-call`, `swl-rehydrate`,
+  `swl-modal-open/-close`, `swl-contextmenu`, `swl-toast`, `swl-reset-form`, `swl-error`, ...),
+  `HX-Redirect`, `HX-Replace-Url`. Empty response = 204, fail = 422 (+ `HX-Reswap: none`).
+- `swl/static/swl/swl.js`: browser side (event handlers, dialogs via `swl.ui`, `swl_action`,
+  `swl.rehydrate`, `swl.kickstart`, toasts); `swl-run.js` boots it; `websocket.js` = live updates
+  (`data-swl-on-changed` placeholders reload when the dispatcher signals a change).
+- `swl/templates/swl/`: `base.j2` (loads htmx + htmx-config meta), `placeholder.j2` (macro),
+  `kickstart.j2`, `modal-content.j2`, account/users views (`swl/views/account.py`).
+- `swl/resources/<framework>-web-resources.json`: CDN scripts/styles per framework, all from
+  cdn.jsdelivr.net with SRI hashes (htmx is `htmx.org@4.0.0`); `web_resources.py` loads them.
+- `swl/test_utils.py`: `assert_success(response)` (returns the events), `assert_fail(response, msg)`.
+- `doc/reference.md`: full reference (deep links, tabs, debugging); `doc/htmx-migration.md`.
+- `example/`: task-list example app (`swl_tasks`), README walks one click end to end.
+  Run: `pip install -e example && python -m swl_tasks`, login demo / demo-password.
+
+## Key conventions (htmx 4 specifics that bite)
+
+- Attributes only inherit when written as `hx-vals:inherited` / `hx-confirm:inherited`.
+- Non-form elements (placeholders, links) post only `hx-vals` + `hx-include`, plus `placeholder=<id>`.
+- `HX-Trigger` events fire after the swap; the source may be detached, so listen on `document`.
+- Recipes for rehydrate live on the element (`hx-post` + `hx-vals`), not in sessionStorage.
+- Deep links: actions call `set_url(...)`, the page route renders that screen; `kickstart` only for
+  state only an action can produce (it waits until placeholders settle: 100 ms quiet, max 5 s).
+- Values from users/urls into `hx-vals` or kickstart: always `|tojson`.
+- Bootstrap tabs: `hx-trigger="show.bs.tab"`, plus `load, ` on the initially active tab. Without
+  Bootstrap: `<nav class="swl-tabs">` with `aria-selected` buttons (see `doc/reference.md`).
+
+## Testing
+
+- Python: `pytest swl example/swl_tasks` (tests are `*_test.py` next to the code; needs
+  `pip install -e . -e example/`). pytest runs with `-n5` (xdist) and `asyncio_mode = auto` from
+  `pyproject.toml`; for one test use `pytest -n0 swl/responses_test.py::test_name`.
+- JavaScript: QUnit tests in `swl/test/js-test/swl.test.js`, served by `python -m swl.test.server`
+  (open http://localhost:8000/). Headless: run that page in Playwright.
+- Style: flake8 (`.flake8`, max line length 90), isort with the black profile.
+
+## Working agreements
+
+- Python >= 3.11; all dependencies come from PyPI. `env/` is a local virtualenv, ignored.
+- Versions come from git tags via `setuptools_scm` (tags like `5.0.0`); `swl/_version.py` is
+  generated and git-ignored. Pushing a version tag to GitHub publishes that version to PyPI
+  (`.github/workflows/publish.yml`), and PyPI never accepts a version twice. Don't push tags
+  unless asked. `.github/workflows/test.yml` runs the tests on every push.
+- Never push or publish to PyPI; that is the maintainers' decision. Commit messages are prefixed
+  `JJ: `. No `Claude-Session:` lines in commit messages.
+- Keep changes on a branch; report behaviour changes and anything left undone.

swl-5.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-2026 Seecr (Seek You Too B.V.) https://seecr.nl
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

swl-5.0.0/PKG-INFO

@@ -0,0 +1,146 @@
+Metadata-Version: 2.4
+Name: swl
+Version: 5.0.0
+Summary: Seecr Web Lib makes developing webbased apps easier
+Author-email: Thijs Janssen <thijs@seecr.nl>, Johan Jonkers <johan@seecr.nl>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/seecr/swl
+Project-URL: Source, https://github.com/seecr/swl
+Project-URL: Changelog, https://github.com/seecr/swl/blob/main/CHANGELOG.md
+Keywords: swl
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: argon2-cffi<26,>=25.1.0
+Requires-Dist: httpx2<3,>=2.16.0
+Requires-Dist: pytest<10,>=9.2.0
+Requires-Dist: pytest-asyncio<2,>=1.4.1
+Requires-Dist: pytest-xdist<4,>=3.8.0
+Requires-Dist: seecr-stdlib<1,>=0.6.5
+Requires-Dist: seecr-testtools<1,>=0.4.3
+Requires-Dist: setuptools-scm<11,>=10.3.4
+Requires-Dist: starlette<2,>=1.10.0
+Requires-Dist: starlette[full]
+Requires-Dist: uvicorn<1,>=0.54.0
+Requires-Dist: uvicorn[standard]
+Dynamic: license-file
+
+# SWL (Seecr Web Lib)
+
+[![Tests](https://github.com/seecr/swl/actions/workflows/test.yml/badge.svg)](https://github.com/seecr/swl/actions/workflows/test.yml)
+[![PyPI](https://img.shields.io/pypi/v/swl.svg)](https://pypi.org/project/swl/)
+
+Interactive web applications in Python, without a JavaScript frontend.
+
+SWL is a small layer on top of [Starlette](https://www.starlette.io),
+[Jinja](https://jinja.palletsprojects.com) and [htmx 4](https://four.htmx.org). The server renders
+HTML; an action answers with a short list of instructions ("put this HTML there, reload that list,
+close the dialog, show a toast") that SWL carries out in the browser. You write Python and
+templates. There is no build step, and no second application to keep in sync.
+
+It is made for the software around data: admin screens, editors, review tools, form builders and
+dashboards. These are lots of forms, lists, dialogs and tabs, used every day by people who need
+them to work.
+
+## A taste
+
+```jinja
+{% from "swl/placeholder.j2" import placeholder %}
+
+<form hx-post="{{ register('note_add') }}">
+    <input name="text" class="{{ SWL.ui.input }}">
+    <button type="submit" class="{{ SWL.ui.button_primary }}">Add</button>
+</form>
+
+{{ placeholder("notes", register('notes_list')) }}
+```
+
+```python
+async def notes_list(request, swl, db, **kwargs):
+    html = swl.template("notes/list.j2").render(notes=db.notes())
+    return swl.success().hydrate("notes", html)
+
+
+async def note_add(request, swl, db, **kwargs):
+    async with request.form() as form:
+        text = form.get("text", "").strip()
+    if not text:
+        return swl.fail().message("A note needs some text")
+    db.add_note(text)
+    return swl.success().reset_form().rehydrate("notes").toast("Note added")
+
+
+__actions__ = [notes_list, note_add]
+```
+
+`note_add` doesn't render the list. It asks the list to reload itself, so `notes_list` stays the
+only place that knows how the list looks. And because a response is data, you test an action
+without a browser.
+
+## What you get
+
+- **Actions**: async Python functions, registered by module, with login and authorisation checks.
+  A template gets an action's url with `register("name")`.
+- **A response builder**: `hydrate`, `rehydrate`, `open_modal`, `close_modal`,
+  `open_contextmenu`, `toast`, `call` (a JavaScript function), `set_url`, `redirect`,
+  `trigger`, and `swl.fail().message(...)` for errors.
+- **Placeholders and rehydrate**: parts of the page that load themselves and can be reloaded by
+  name from any action.
+- **Live updates**: a placeholder can reload when the data it shows changes, also in other
+  browser tabs and for other users (over a websocket).
+- **Screens you can reload and link to**: actions keep the url up to date, and a page route
+  renders the same screen from it.
+- **Ready-made parts**: a modal, confirm and error dialogs, toasts and context menus, all
+  plain HTML (`<dialog>`, popover). There are also login, "my account" and user management
+  screens.
+- **Your choice of CSS framework**: `ui.framework` is `"bootstrap"` (the default), `"tabler"`,
+  `"bulma"` or `"swl"`, SWL's own small stylesheet with no framework at all. Light and dark
+  colours work with each of them.
+
+## Install
+
+```sh
+pip install swl
+```
+
+Or from a checkout: `pip install -e .`. SWL needs Python 3.11 or newer. Its dependencies, including `seecr-stdlib`, come from PyPI.
+
+## Try the example
+
+The example application is a small task list. It uses nearly everything: dialogs, search as you
+type, tabs, a context menu, live updates between browser tabs, screens that survive a reload,
+and switches for the CSS framework and dark mode.
+
+```sh
+pip install -e .
+pip install -e example/
+python -m swl_tasks
+```
+
+Open <http://127.0.0.1:8000/> and log in as **demo** / **demo-password**.
+
+## Documentation
+
+- [`example/README.md`](example/README.md): a guided walk through the example, from one click to
+  the updated list. Start here.
+- [`doc/reference.md`](doc/reference.md): everything SWL provides, for looking things up. Also
+  covers debugging and troubleshooting.
+- [`doc/htmx-migration.md`](doc/htmx-migration.md): upgrading an application from SWL 4 (jQuery,
+  `data-swl-*` attributes) to the htmx version.
+- [`CHANGELOG.md`](CHANGELOG.md): what changed.
+
+## Tests
+
+```sh
+pytest swl example/swl_tasks
+```
+
+The JavaScript tests (QUnit) run in a browser: `python -m swl.test.server`, then open
+<http://localhost:8000/>.
+
+## License
+
+SWL is released under the MIT License; see [LICENSE](LICENSE).
+
+Copyright © Seecr (Seek You Too B.V.), <https://seecr.nl>.

swl-5.0.0/README.md

@@ -0,0 +1,118 @@
+# SWL (Seecr Web Lib)
+
+[![Tests](https://github.com/seecr/swl/actions/workflows/test.yml/badge.svg)](https://github.com/seecr/swl/actions/workflows/test.yml)
+[![PyPI](https://img.shields.io/pypi/v/swl.svg)](https://pypi.org/project/swl/)
+
+Interactive web applications in Python, without a JavaScript frontend.
+
+SWL is a small layer on top of [Starlette](https://www.starlette.io),
+[Jinja](https://jinja.palletsprojects.com) and [htmx 4](https://four.htmx.org). The server renders
+HTML; an action answers with a short list of instructions ("put this HTML there, reload that list,
+close the dialog, show a toast") that SWL carries out in the browser. You write Python and
+templates. There is no build step, and no second application to keep in sync.
+
+It is made for the software around data: admin screens, editors, review tools, form builders and
+dashboards. These are lots of forms, lists, dialogs and tabs, used every day by people who need
+them to work.
+
+## A taste
+
+```jinja
+{% from "swl/placeholder.j2" import placeholder %}
+
+<form hx-post="{{ register('note_add') }}">
+    <input name="text" class="{{ SWL.ui.input }}">
+    <button type="submit" class="{{ SWL.ui.button_primary }}">Add</button>
+</form>
+
+{{ placeholder("notes", register('notes_list')) }}
+```
+
+```python
+async def notes_list(request, swl, db, **kwargs):
+    html = swl.template("notes/list.j2").render(notes=db.notes())
+    return swl.success().hydrate("notes", html)
+
+
+async def note_add(request, swl, db, **kwargs):
+    async with request.form() as form:
+        text = form.get("text", "").strip()
+    if not text:
+        return swl.fail().message("A note needs some text")
+    db.add_note(text)
+    return swl.success().reset_form().rehydrate("notes").toast("Note added")
+
+
+__actions__ = [notes_list, note_add]
+```
+
+`note_add` doesn't render the list. It asks the list to reload itself, so `notes_list` stays the
+only place that knows how the list looks. And because a response is data, you test an action
+without a browser.
+
+## What you get
+
+- **Actions**: async Python functions, registered by module, with login and authorisation checks.
+  A template gets an action's url with `register("name")`.
+- **A response builder**: `hydrate`, `rehydrate`, `open_modal`, `close_modal`,
+  `open_contextmenu`, `toast`, `call` (a JavaScript function), `set_url`, `redirect`,
+  `trigger`, and `swl.fail().message(...)` for errors.
+- **Placeholders and rehydrate**: parts of the page that load themselves and can be reloaded by
+  name from any action.
+- **Live updates**: a placeholder can reload when the data it shows changes, also in other
+  browser tabs and for other users (over a websocket).
+- **Screens you can reload and link to**: actions keep the url up to date, and a page route
+  renders the same screen from it.
+- **Ready-made parts**: a modal, confirm and error dialogs, toasts and context menus, all
+  plain HTML (`<dialog>`, popover). There are also login, "my account" and user management
+  screens.
+- **Your choice of CSS framework**: `ui.framework` is `"bootstrap"` (the default), `"tabler"`,
+  `"bulma"` or `"swl"`, SWL's own small stylesheet with no framework at all. Light and dark
+  colours work with each of them.
+
+## Install
+
+```sh
+pip install swl
+```
+
+Or from a checkout: `pip install -e .`. SWL needs Python 3.11 or newer. Its dependencies, including `seecr-stdlib`, come from PyPI.
+
+## Try the example
+
+The example application is a small task list. It uses nearly everything: dialogs, search as you
+type, tabs, a context menu, live updates between browser tabs, screens that survive a reload,
+and switches for the CSS framework and dark mode.
+
+```sh
+pip install -e .
+pip install -e example/
+python -m swl_tasks
+```
+
+Open <http://127.0.0.1:8000/> and log in as **demo** / **demo-password**.
+
+## Documentation
+
+- [`example/README.md`](example/README.md): a guided walk through the example, from one click to
+  the updated list. Start here.
+- [`doc/reference.md`](doc/reference.md): everything SWL provides, for looking things up. Also
+  covers debugging and troubleshooting.
+- [`doc/htmx-migration.md`](doc/htmx-migration.md): upgrading an application from SWL 4 (jQuery,
+  `data-swl-*` attributes) to the htmx version.
+- [`CHANGELOG.md`](CHANGELOG.md): what changed.
+
+## Tests
+
+```sh
+pytest swl example/swl_tasks
+```
+
+The JavaScript tests (QUnit) run in a browser: `python -m swl.test.server`, then open
+<http://localhost:8000/>.
+
+## License
+
+SWL is released under the MIT License; see [LICENSE](LICENSE).
+
+Copyright © Seecr (Seek You Too B.V.), <https://seecr.nl>.