Authentication support

2022-09-24 19:54:26 +01:00
188 changed files with 7078 additions and 10287 deletions
--- a/.coveragerc
+++ b/.coveragerc
@@ -0,0 +1,5 @@
+[run]
+omit=
+    src/microdot_websocket_alt.py
+    src/microdot_asgi_websocket.py
+    src/microdot_ssl.py
--- a/.flake8
+++ b/.flake8
@@ -0,0 +1,3 @@
+[flake8]
+select = C,E,F,W,B,B950
+per-file-ignores = ./*/__init__.py:F401
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@@ -0,0 +1,3 @@
+github: miguelgrinberg
+patreon: miguelgrinberg
+custom: https://paypal.me/miguelgrinberg
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -1,26 +0,0 @@
---
-name: Bug report
-about: Create a report to help us improve
-title: ''
-labels: ''
-assignees: ''
-
---
-
-**IMPORTANT**: If you have a question, or you are not sure if you have found a bug in this package, then you are in the wrong place. Hit back in your web browser, and then open a GitHub Discussion instead. Likewise, if you are unable to provide the information requested below, open a discussion to troubleshoot your issue.
-
-**Describe the bug**
-A clear and concise description of what the bug is. If you are getting errors, please include the complete error message, including the stack trace.
-
-**To Reproduce**
-Steps to reproduce the behavior:
-1. Go to '...'
-2. Click on '....'
-3. Scroll down to '....'
-4. See error
-
-**Expected behavior**
-A clear and concise description of what you expected to happen.
-
-**Additional context**
-Add any other context about the problem here.
--- a/.github/ISSUE_TEMPLATE/config.yml
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -1,5 +0,0 @@
-blank_issues_enabled: false
-contact_links:
-  - name: GitHub Discussions
-    url: https://github.com/miguelgrinberg/microdot/discussions
-    about: Ask questions here.
--- a/.github/ISSUE_TEMPLATE/feature_request.md
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@@ -1,20 +0,0 @@
---
-name: Feature request
-about: Suggest an idea for this project
-title: ''
-labels: ''
-assignees: ''
-
---
-
-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen.
-
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
-
-**Additional context**
-Add any other context or screenshots about the feature request here.
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -11,23 +11,22 @@ jobs:
    name: lint
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v3
+      - uses: actions/checkout@v2
+      - uses: actions/setup-python@v2
      - run: python -m pip install --upgrade pip wheel
      - run: pip install tox tox-gh-actions
      - run: tox -eflake8
-      - run: tox -edocs
  tests:
    name: tests
    strategy:
      matrix:
        os: [ubuntu-latest, macos-latest, windows-latest]
-        python: ['3.8', '3.9', '3.10', '3.11', '3.12']
+        python: ['3.6', '3.7', '3.8', '3.9', '3.10']
      fail-fast: false
    runs-on: ${{ matrix.os }}
    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v3
+      - uses: actions/checkout@v2
+      - uses: actions/setup-python@v2
        with:
          python-version: ${{ matrix.python }}
      - run: python -m pip install --upgrade pip wheel
@@ -37,40 +36,27 @@ jobs:
    name: tests-micropython
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v3
+      - uses: actions/checkout@v2
+      - uses: actions/setup-python@v2
      - run: python -m pip install --upgrade pip wheel
      - run: pip install tox tox-gh-actions
      - run: tox -eupy
-  tests-circuitpython:
-    name: tests-circuitpython
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v3
-      - run: python -m pip install --upgrade pip wheel
-      - run: pip install tox tox-gh-actions
-      - run: tox -ecpy
  coverage:
    name: coverage
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v3
+      - uses: actions/checkout@v2
+      - uses: actions/setup-python@v2
      - run: python -m pip install --upgrade pip wheel
-      - run: pip install tox tox-gh-actions
+      - run: pip install tox tox-gh-actions codecov
      - run: tox
-      - uses: codecov/codecov-action@v3
-        with:
-          files: ./coverage.xml
-          fail_ci_if_error: true
-          token: ${{ secrets.CODECOV_TOKEN }}
+      - run: codecov
  benchmark:
    name: benchmark
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v3
+      - uses: actions/checkout@v2
+      - uses: actions/setup-python@v2
      - run: python -m pip install --upgrade pip wheel
      - run: pip install tox tox-gh-actions
      - run: tox -ebenchmark
--- a/.gitignore
+++ b/.gitignore
@@ -25,8 +25,6 @@ wheels/
 .installed.cfg
 *.egg
 MANIFEST
-requirements.txt
-requirements-dev.txt

 # PyInstaller
 #  Usually these files are written by a python script from a template
@@ -92,8 +90,6 @@ venv/
 ENV/
 env.bak/
 venv.bak/
-.direnv
-.envrc

 # Spyder project settings
 .spyderproject
@@ -107,8 +103,3 @@ venv.bak/

 # mypy
 .mypy_cache/
-
-# other
-*.der
-*.pem
-*_txt.py
--- a/.readthedocs.yaml
+++ b/.readthedocs.yaml
@@ -1,16 +0,0 @@
-version: 2
-
-build:
-  os: ubuntu-22.04
-  tools:
-    python: "3.11"
-
-sphinx:
-  configuration: docs/conf.py
-
-python:
-  install:
-    - method: pip
-      path: .
-      extra_requirements:
-        - docs
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,189 +1,5 @@
 # Microdot change log

-**Release 2.3.3** - 2025-07-01
-
- Handle partial reads in WebSocket class [#294](https://github.com/miguelgrinberg/microdot/issues/294) ([commit](https://github.com/miguelgrinberg/microdot/commit/9bc3dced6c1f582dde0496961d25170b448ad8d7))
- Add SVG to supported mimetypes [#302](https://github.com/miguelgrinberg/microdot/issues/302) ([commit](https://github.com/miguelgrinberg/microdot/commit/1d419ce59bf7006617109c05dc2d6fc6d1dc8235)) (thanks **Ozuba**!)
- Do not silence exceptions that occur in the SSE task ([commit](https://github.com/miguelgrinberg/microdot/commit/654a85f46b7dd7a1e94f81193c4a78a8a1e99936))
- Add Support for SSE responses in the test client ([commit](https://github.com/miguelgrinberg/microdot/commit/f5d3d931edfbacedebf5fdf938ef77c5ee910380))
- Documentation improvements for the `Request` class ([commit](https://github.com/miguelgrinberg/microdot/commit/3dffa05ffb229813156b71e10a85283bdaa26d5e))
- Additional documentation for the `URLPattern` class ([commit](https://github.com/miguelgrinberg/microdot/commit/786e5e533748e1343612c97123773aec9a1a99fc))
- More detailed documentation for route responses ([commit](https://github.com/miguelgrinberg/microdot/commit/dc61470fa959549bb43313906ba6ed9f686babc2))
- Additional documentation on WebSocket and SSE disconnections ([commit](https://github.com/miguelgrinberg/microdot/commit/7c98c4589de4774a88381b393444c75094532550))
- More detailed documentation for `current_user` ([commit](https://github.com/miguelgrinberg/microdot/commit/e146e2d08deddf9b924c7657f04db28d71f34221))
- Add a sub-application example ([commit](https://github.com/miguelgrinberg/microdot/commit/d7a9c535639268e415714b12ac898ae38e516308))
-
-**Release 2.3.2** - 2025-05-08
-
- Use async error handlers in auth module [#298](https://github.com/miguelgrinberg/microdot/issues/298) ([commit](https://github.com/miguelgrinberg/microdot/commit/d9d7ff0825e4c5fbed6564d3684374bf3937df11))
-
-**Release 2.3.1** - 2025-04-13
-
- Additional support needed when using `orjson` ([commit](https://github.com/miguelgrinberg/microdot/commit/cd0b3234ddb0c8ff4861d369836ec2aed77494db))
-
-**Release 2.3.0** - 2025-04-12
-
- Support optional authentication methods ([commit](https://github.com/miguelgrinberg/microdot/commit/f317b15bdbf924007e5e3414e0c626baccc3ede6))
- Catch SSL exceptions while writing the response [#206](https://github.com/miguelgrinberg/microdot/issues/206) ([commit](https://github.com/miguelgrinberg/microdot/commit/e7ee74d6bba74cfd89b9ddc38f28e02514eb1791))
- Use `orjson` instead of `json` if available ([commit](https://github.com/miguelgrinberg/microdot/commit/086f2af3deab86d4340f3f1feb9e019de59f351d))
- Addressed typing warnings from pyright ([commit](https://github.com/miguelgrinberg/microdot/commit/b6f232db1125045d79c444c736a2ae59c5501fdd))
-
-**Release 2.2.0** - 2025-03-22
-
- Support for `multipart/form-data` requests [#287](https://github.com/miguelgrinberg/microdot/issues/287) ([commit](https://github.com/miguelgrinberg/microdot/commit/11a91a60350518e426b557fae8dffe75912f8823))
- Support custom path components in URLs ([commit #1](https://github.com/miguelgrinberg/microdot/commit/c92b5ae28222af5a1094f5d2f70a45d4d17653d5) [commit #2](https://github.com/miguelgrinberg/microdot/commit/aa76e6378b37faab52008a8aab8db75f81b29323))
- Expose the Jinja environment as `Template.jinja_env` ([commit](https://github.com/miguelgrinberg/microdot/commit/953dd9432122defe943f0637bbe7e01f2fc7743f))
- Simplified urldecode logic ([commit #1](https://github.com/miguelgrinberg/microdot/commit/3bc31f10b2b2d4460c62366013278d87665f0f97) [commit #2](https://github.com/miguelgrinberg/microdot/commit/d203df75fef32c7cc0fe7cc6525e77522b37a289))
- Additional urldecode tests ([commit](https://github.com/miguelgrinberg/microdot/commit/99f65c0198590c0dfb402c24685b6f8dfba1935d))
- Documentation improvements ([commit](https://github.com/miguelgrinberg/microdot/commit/c6b99b6d8117d4e40e16d5b953dbf4deb023d24d))
- Update micropython version used in tests to 1.24.1 ([commit](https://github.com/miguelgrinberg/microdot/commit/4cc2e95338a7de3b03742389004147ee21285621))
-
-**Release 2.1.0** - 2025-02-04
-
- User login support ([commit](https://github.com/miguelgrinberg/microdot/commit/d807011ad006e53e70c4594d7eac04d03bb08681))
- Basic and token authentication support ([commit](https://github.com/miguelgrinberg/microdot/commit/675c9787974da926af446974cd96ef224e0ee27f))
- Added `local` argument to the `app.mount()` method, to define sub-application specific before and after request handlers ([commit](https://github.com/miguelgrinberg/microdot/commit/fd7931e1aec173c60f81dad18c1a102ed8f0e081))
- Added `Request.url_prefix`, `Request.subapp` and local mounts ([commit](https://github.com/miguelgrinberg/microdot/commit/fd7931e1aec173c60f81dad18c1a102ed8f0e081))
- Added a front end to the SSE example [#281](https://github.com/miguelgrinberg/microdot/issues/281) ([commit](https://github.com/miguelgrinberg/microdot/commit/d487a73c1ea5b3467e23907618b348ca52e0235c)) (thanks **Maxi**!)
- Additional ``app.mount()`` unit tests ([commit](https://github.com/miguelgrinberg/microdot/commit/cd87abba30206ec6d3928e0aabacb2fccf7baf70))
-
-**Release 2.0.7** - 2024-11-10
-
- Accept responses with just a status code [#263](https://github.com/miguelgrinberg/microdot/issues/263) ([commit #1](https://github.com/miguelgrinberg/microdot/commit/4eac013087f807cafa244b8a6b7b0ed4c82ff150) [commit #2](https://github.com/miguelgrinberg/microdot/commit/c46e4291061046f1be13f300dd08645b71c16635))
- Fixed compressed file content-type assignment [#251](https://github.com/miguelgrinberg/microdot/issues/251) ([commit](https://github.com/miguelgrinberg/microdot/commit/482ab6d5ca068d71ea6301f45918946161e9fcc1)) (thanks **Lukas Kremla**!)
- Better documentation for start_server[#252](https://github.com/miguelgrinberg/microdot/issues/252) ([commit](https://github.com/miguelgrinberg/microdot/commit/0a021462e0c42c249d587a2d600f5a21a408adfc))
- Fix URLs in documentation [#253](https://github.com/miguelgrinberg/microdot/issues/253) ([commit](https://github.com/miguelgrinberg/microdot/commit/5e5fc5e93e11cbf6e3dc8036494e8732d1815d3e)) (thanks **Stanislav Garanzha**!)
-
-**Release 2.0.6** - 2024-06-18
-
- Add event ID to the SSE implementation [#213](https://github.com/miguelgrinberg/microdot/issues/213) ([commit](https://github.com/miguelgrinberg/microdot/commit/904d5fcaa2d19d939a719b8e68c4dee3eb470739)) (thanks **Hamsanger**!)
- Configurable session cookie options [#242](https://github.com/miguelgrinberg/microdot/issues/242) ([commit](https://github.com/miguelgrinberg/microdot/commit/0151611fc84fec450820d673f4c4d70c32c990a7))
- Improved cookie support in the test client ([commit](https://github.com/miguelgrinberg/microdot/commit/4cb155ee411dc2d9c9f15714cb32b25ba79b156a))
- Cookie path support in session extension and test client ([commit](https://github.com/miguelgrinberg/microdot/commit/6ffb8a8fe920111c4d8c16e98715a0d5ee2d1da3))
- Refactor `Session` class to make it more reusable ([commit](https://github.com/miguelgrinberg/microdot/commit/dea79c5ce224dec7858ffef45a42bed442fd3a5a))
- Use `@functools.wraps` on decorated functions ([commit](https://github.com/miguelgrinberg/microdot/commit/f6876c0d154adcae96098405fb6a1fdf1ea4ec28))
- Removed outdated import from documentation [#216](https://github.com/miguelgrinberg/microdot/issues/216) ([commit](https://github.com/miguelgrinberg/microdot/commit/6b1fd6191702e7a9ad934fddfcdd0a3cebea7c94)) (thanks **Carlo Colombo**!)
- Add roadmap details to readme ([commit](https://github.com/miguelgrinberg/microdot/commit/a0ea439def238084c4d68309c0992b66ffd28ad6))
-
-**Release 2.0.5** - 2024-03-09
-
- Correct handling of 0 as an integer argument (regression from #207) [#212](https://github.com/miguelgrinberg/microdot/issues/212) ([commit](https://github.com/miguelgrinberg/microdot/commit/d0a4cf8fa7dfb1da7466157b18d3329a8cf9a5df))
-
-**Release 2.0.4** - 2024-02-20
-
- Do not use regexes for parsing simple URLs [#207](https://github.com/miguelgrinberg/microdot/issues/207) ([commit #1](https://github.com/miguelgrinberg/microdot/commit/38262c56d34784401659639b482a4a1224e1e59a) [commit #2](https://github.com/miguelgrinberg/microdot/commit/f6cba2c0f7e18e2f32b5adb779fb037b6c473eab))
- Added documentation on using alternative uTemplate loaders ([commit](https://github.com/miguelgrinberg/microdot/commit/bf519478cbc6e296785241cd7d01edb23c317cd3))
- Added CircuitPython builds ([commit](https://github.com/miguelgrinberg/microdot/commit/e44c271bae88f4327d3eda16d8780ac264d1ebab))
-
-**Release 2.0.3** - 2024-01-07
-
- Add a limit to WebSocket message size [#193](https://github.com/miguelgrinberg/microdot/issues/193) ([commit](https://github.com/miguelgrinberg/microdot/commit/5d188e8c0ddef6ce633ca702dbdd4a90f2799597))
- Pass keyword arguments to thread executor in the correct way [#195](https://github.com/miguelgrinberg/microdot/issues/195) ([commit](https://github.com/miguelgrinberg/microdot/commit/6712c47400d7c426c88032f65ab74466524eccab))
- Update uasyncio library used in tests to include new TLS support ([commit](https://github.com/miguelgrinberg/microdot/commit/c8c91e83457d24320f22c9a74e80b15e06b072ca))
- Documentation improvements ([commit](https://github.com/miguelgrinberg/microdot/commit/b80b6b64d02d21400ca8a5077f5ed1127cc202ae))
-
-**Release 2.0.2** - 2023-12-28
-
- Support binary data in the SSE extension ([commit](https://github.com/miguelgrinberg/microdot/commit/1fc11193da0d298f5539e2ad218836910a13efb2))
- Upgrade micropython tests to use v1.22 + initial CircuitPython testing work ([commit](https://github.com/miguelgrinberg/microdot/commit/79452a46992351ccad2c0317c20bf50be0d76641))
- Improvements to migration guide ([commit](https://github.com/miguelgrinberg/microdot/commit/84842e39c360a8b3ddf36feac8af201fb19bbb0b))
- Remove spurious async in documentation example [#187](https://github.com/miguelgrinberg/microdot/issues/187) ([commit](https://github.com/miguelgrinberg/microdot/commit/ad368be993e2e3007579f1d3880e36d60c71da92)) (thanks **Tak Tran**!)
-
-**Release 2.0.1** - 2023-12-23
-
- Addressed some inadvertent mistakes in the template extensions ([commit](https://github.com/miguelgrinberg/microdot/commit/bd18ceb4424e9dfb52b1e6d498edd260aa24fc53))
-
-**Release 2.0.0** - 2023-12-22
-
- Major redesign [#186](https://github.com/miguelgrinberg/microdot/issues/186) ([commit](https://github.com/miguelgrinberg/microdot/commit/20ea305fe793eb206b52af9eb5c5f3c1e9f57dbb))
-    - Code reorganization as a `microdot` package
-    - Asyncio is now the core implementation
-    - New support for Server-Sent Events (SSE)
-    - Several extensions redesigned
-    - Support for "partitioned" cookies
-    - [Cross-compiling and freezing](https://microdot.readthedocs.io/en/stable/freezing.html) guidance
-    - A [Migration Guide](https://microdot.readthedocs.io/en/stable/migrating.html) to help transition to version 2 from older releases
-
-**Release 1.3.4** - 2023-11-08
-
- Handle change in `wait_closed()` behavior in Python 3.12 [#177](https://github.com/miguelgrinberg/microdot/issues/177) ([commit](https://github.com/miguelgrinberg/microdot/commit/5550b20cdd347d59e2aa68f6ebf9e9abffaff9fc))
- Added missing request argument in some documentation examples [#163](https://github.com/miguelgrinberg/microdot/issues/163) ([commit](https://github.com/miguelgrinberg/microdot/commit/744548f8dc33a72512b34c4001ee9c6c1edd22ee))
- Fix minor documentation typos [#161](https://github.com/miguelgrinberg/microdot/issues/161) ([commit](https://github.com/miguelgrinberg/microdot/commit/2e4911d10826cbb3914de4a45e495c3be36543fa)) (thanks **Andy Piper**!)
-
-**Release 1.3.3** - 2023-07-16
-
- Handle query string arguments without value [#149](https://github.com/miguelgrinberg/microdot/issues/149) ([commit](https://github.com/miguelgrinberg/microdot/commit/3554bc91cb1523efa5b66fe3ef173f8e86e8c2a0))
- Support empty responses with ASGI adapter ([commit](https://github.com/miguelgrinberg/microdot/commit/e09e9830f43af41d38775547637558494151a385))
- Added CORS extension to Python package ([commit](https://github.com/miguelgrinberg/microdot/commit/304ca2ef6881fe718126b3e308211e760109d519))
- Document access to WSGI and ASGI attributes [#153](https://github.com/miguelgrinberg/microdot/issues/153) ([commit](https://github.com/miguelgrinberg/microdot/commit/d99df2c4010ab70c60b86ab334d656903e04eb26))
- Upgrade micropython tests to use v1.20 ([commit](https://github.com/miguelgrinberg/microdot/commit/e0f0565551966ee0238a5a1819c78a13639ad704))
-
-**Release 1.3.2** - 2023-06-13
-
- In ASGI, return headers as strings and not binary [#144](https://github.com/miguelgrinberg/microdot/issues/144) ([commit](https://github.com/miguelgrinberg/microdot/commit/e92310fa55bbffcdcbb33f560e27c3579d7ac451))
- Incorrect import in `static_async.py` example ([commit](https://github.com/miguelgrinberg/microdot/commit/c07a53943508e64baea160748e67efc92e75b036))
-
-**Release 1.3.1** - 2023-05-21
-
- Support negative numbers for int path components [#137](https://github.com/miguelgrinberg/microdot/issues/137) ([commit](https://github.com/miguelgrinberg/microdot/commit/a0dd7c8ab6d681932324e56ed101aba861a105a0))
- Use a more conservative default for socket timeout [#130](https://github.com/miguelgrinberg/microdot/issues/130) ([commit](https://github.com/miguelgrinberg/microdot/commit/239cf4ff37268a7e2467b93be44fe9f91cee8aee))
- More robust check for socket timeout error code [#106](https://github.com/miguelgrinberg/microdot/issues/106) ([commit](https://github.com/miguelgrinberg/microdot/commit/efec9f14be7b6f3451e4d1d0fe7e528ce6ca74dc))
- WebSocket error when handling PING packet [#129](https://github.com/miguelgrinberg/microdot/issues/129) ([commit](https://github.com/miguelgrinberg/microdot/commit/87cd098f66e24bed6bbad29b1490a129e355bbb3))
- Explicitly set UTF-8 encoding for HTML files in examples [#132](https://github.com/miguelgrinberg/microdot/issues/132) ([commit](https://github.com/miguelgrinberg/microdot/commit/f81de6d9582f4905b9c2735d3c639b92d7e77994))
-
-**Release 1.3.0** - 2023-04-08
-
- Cross-Origin Resource Sharing (CORS) extension [#45](https://github.com/miguelgrinberg/microdot/issues/45) ([commit](https://github.com/miguelgrinberg/microdot/commit/67798f7dbffb30018ab4b62a9aaa297f63bc9e64))
- Respond to `HEAD` and `OPTIONS` requests ([commit](https://github.com/miguelgrinberg/microdot/commit/6a31f89673518e79fef5659c04e609b7976a5e34))
- Tolerate slightly invalid formats in query strings [#126](https://github.com/miguelgrinberg/microdot/issues/126) ([commit](https://github.com/miguelgrinberg/microdot/commit/a1b061656fa19dae583951596b0f1f0603652a56))
- Support compressed files in `send_file()` [#93](https://github.com/miguelgrinberg/microdot/issues/93) ([commit](https://github.com/miguelgrinberg/microdot/commit/daf1001ec55ab38e6cdfee4931729a3b7506858b))
- Add `max_age` argument to `send_file()` ([commit](https://github.com/miguelgrinberg/microdot/commit/e684ee32d91d3e2ab9569bb5fd342986c010ffeb))
- Add `update()` method to `NoCaseDict` class ([commit](https://github.com/miguelgrinberg/microdot/commit/ea6766cea96b756b36ed777f9c1b6a6680db09ba))
- Set exit code to 1 for failed MicroPython test runs ([commit](https://github.com/miguelgrinberg/microdot/commit/a350e8fd1e55fac12c9e5b909cfa82d880b177ef))
-
-**Release 1.2.4** - 2023-03-03
-
- One more attempt to correct build issues ([commit](https://github.com/miguelgrinberg/microdot/commit/cb39898829f4edc233ab4e7ba3f7ef3c5c50f196))
-
-**Release 1.2.3** - 2023-03-03
-
- Corrected a problem with previous build.
-
-**Release 1.2.2** - 2023-03-03
-
- Add a socket read timeout to abort incomplete requests [#99](https://github.com/miguelgrinberg/microdot/issues/99) ([commit](https://github.com/miguelgrinberg/microdot/commit/d0d358f94a63f8565d6406feff0c6e7418cc7f81))
- More robust timeout handling [#106](https://github.com/miguelgrinberg/microdot/issues/106) ([commit](https://github.com/miguelgrinberg/microdot/commit/4d432a7d6cd88b874a8b825fb62891ed22881f74))
- Add @after_error_handler decorator [#97](https://github.com/miguelgrinberg/microdot/issues/97) ([commit](https://github.com/miguelgrinberg/microdot/commit/fcaeee69052b5681706f65b022e667baeee30d4d))
- Return headers as lowercase byte sequences as required by ASGI ([commit](https://github.com/miguelgrinberg/microdot/commit/ddb3b8f442d3683df04554104edaf8acd9c68148))
- Async example of static file serving ([commit](https://github.com/miguelgrinberg/microdot/commit/680cd9c023352f0ff03d67f1041ea174b7b7385b))
- Fixing broken links to examples in documentation [#101](https://github.com/miguelgrinberg/microdot/issues/101) ([commit](https://github.com/miguelgrinberg/microdot/commit/c00b24c9436e1b8f3d4c9bb6f2adfca988902e91)) (thanks **Eric Welch**!)
- Add scrollbar to documentation's left sidebar ([commit](https://github.com/miguelgrinberg/microdot/commit/2aa90d42451dc64c84efcc4f40a1b6c8d1ef1e8d))
- Documentation typo [#90](https://github.com/miguelgrinberg/microdot/issues/90) ([commit](https://github.com/miguelgrinberg/microdot/commit/81394980234f24aac834faf8e2e8225231e9014b)) (thanks **William Wheeler**!)
- Add CPU timing to benchmark ([commit](https://github.com/miguelgrinberg/microdot/commit/9398c960752f87bc32d7c4349cbf594e5d678e99))
- Upgrade uasyncio release used in tests ([commit](https://github.com/miguelgrinberg/microdot/commit/3d6815119ca1ec989f704f626530f938c857a8e5))
- Update unittest library for MicroPython ([commit](https://github.com/miguelgrinberg/microdot/commit/ecd84ecb7bd3c29d5af96739442b908badeab804))
- New build of micropython for unit tests ([commit](https://github.com/miguelgrinberg/microdot/commit/818f98d9a4e531e01c0f913813425ab2b40c289d))
- Remove 3.6, add 3.11 to builds ([commit](https://github.com/miguelgrinberg/microdot/commit/dd15d90239b73b5fd413515c9cd4ac23f6d42f67))
-
-**Release 1.2.1** - 2022-12-06
-
- Error handling invokes parent exceptions [#74](https://github.com/miguelgrinberg/microdot/issues/74) ([commit](https://github.com/miguelgrinberg/microdot/commit/24d74fb8483b04e8abe6e303e06f0a310f32700b)) (thanks **Diego Pomares**!)
- Addressed error when deleting a user session in async app [#86](https://github.com/miguelgrinberg/microdot/issues/86) ([commit](https://github.com/miguelgrinberg/microdot/commit/5a589afd5e519e94e84fc1ee69033f2dad51c3ea))
- Add asyncio file upload example ([commit](https://github.com/miguelgrinberg/microdot/commit/c841cbedda40f59a9d87f6895fdf9fd954f854a2))
- New Jinja and uTemplate examples with Bootstrap ([commit](https://github.com/miguelgrinberg/microdot/commit/211ad953aeedb4c7f73fe210424aa173b4dc7fee))
- Fix typos in documentation [#77](https://github.com/miguelgrinberg/microdot/issues/77) ([commit](https://github.com/miguelgrinberg/microdot/commit/4a9b92b800d3fd87110f7bc9f546c10185ee13bc)) (thanks **Diego Pomares**!)
- Add missing exception argument to error handler example in documentation [#73](https://github.com/miguelgrinberg/microdot/issues/73) ([commit](https://github.com/miguelgrinberg/microdot/commit/c443599089f2127d1cb052dfba8a05c1969d65e3)) (thanks **Diego Pomares**!)
-
-**Release 1.2.0** - 2022-09-25
-
- Use a case insensitive dict for headers ([commit #1](https://github.com/miguelgrinberg/microdot/commit/b0fd6c432371ca5cb10d07ff84c4deed7aa0ce2e) [commit #2](https://github.com/miguelgrinberg/microdot/commit/a8515c97b030f942fa6ca85cbe1772291468fb0d))
- urlencode() helper function ([commit #1](https://github.com/miguelgrinberg/microdot/commit/672512e086384e808489305502e6ebebcc5a888f) [commit #2](https://github.com/miguelgrinberg/microdot/commit/b133dcc34368853ee685396a1bcb50360e807813))
- Added `request.url` attribute with the complete URL of the request ([commit](https://github.com/miguelgrinberg/microdot/commit/1547e861ee28d43d10fe4c4ed1871345d4b81086))
- Do not log HTTPException occurrences ([commit](https://github.com/miguelgrinberg/microdot/commit/cbefb6bf3a3fdcff8b7a8bacad3449be18e46e3b))
- Cache user session for performance ([commit](https://github.com/miguelgrinberg/microdot/commit/01947b101ebe198312c88d73872e3248024918f0))
- File upload example ([commit](https://github.com/miguelgrinberg/microdot/commit/8ebe81c09b604ddc1123e78ad6bc87ceda5f8597))
- Minor documentation styling fixes ([commit](https://github.com/miguelgrinberg/microdot/commit/4f263c63ab7bb1ce0dd48d8e00f3c6891e1bf07e))
-
 **Release 1.1.1** - 2022-09-18

 - Make WebSocket internals consistent between TLS and non-TLS [#61](https://github.com/miguelgrinberg/microdot/issues/61) ([commit](https://github.com/miguelgrinberg/microdot/commit/5693b812ceb2c0d51ec3c991adf6894a87e6fcc7))
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -1,5 +0,0 @@
-include README.md LICENSE tox.ini
-recursive-include docs *
-recursive-exclude docs/_build *
-recursive-include tests *
-exclude **/*.pyc
--- a/README.md
+++ b/README.md
@@ -3,9 +3,9 @@

 *“The impossibly small web framework for Python and MicroPython”*

-Microdot is a minimalistic Python web framework inspired by Flask. Given its
-small size, it can run on systems with limited resources such as
-microcontrollers. Both standard Python (CPython) and MicroPython are supported.
+Microdot is a minimalistic Python web framework inspired by Flask, and designed
+to run on systems with limited resources such as microcontrollers. It runs on
+standard Python and on MicroPython.

 ```python
 from microdot import Microdot
@@ -13,44 +13,13 @@ from microdot import Microdot
 app = Microdot()

@app.route('/')
-async def index(request):
+def index(request):
    return 'Hello, world!'

 app.run()
 ```

-## Migrating to Microdot 2
-
-Version 2 of Microdot incorporates feedback received from users of earlier
-releases, and attempts to improve and correct some design decisions that have
-proven to be problematic.
-
-For this reason most applications built for earlier versions will need to be
-updated to work correctly with Microdot 2. The
-[Migration Guide](https://microdot.readthedocs.io/en/stable/migrating.html)
-describes the backwards incompatible changes that were made.
-
 ## Resources

+- [Documentation](https://microdot.readthedocs.io/en/latest/)
 - [Change Log](https://github.com/miguelgrinberg/microdot/blob/main/CHANGES.md)
- Documentation
-    - [Latest](https://microdot.readthedocs.io/en/latest/)
-    - [Stable (v2)](https://microdot.readthedocs.io/en/stable/)
-    - [Legacy (v1)](https://microdot.readthedocs.io/en/v1/) ([Code](https://github.com/miguelgrinberg/microdot/tree/v1))
-
-## Roadmap
-
-The following features are planned for future releases of Microdot, both for
-MicroPython and CPython:
-
- Authentication support, similar to [Flask-Login](https://github.com/maxcountryman/flask-login) for Flask (**Added in version 2.1**)
- Support for forms encoded in `multipart/form-data` format (**Added in version 2.2**)
- OpenAPI integration, similar to [APIFairy](https://github.com/miguelgrinberg/apifairy) for Flask
-
-In addition to the above, the following extensions are also under consideration,
-but only for CPython:
-
- Database integration through [SQLAlchemy](https://github.com/sqlalchemy/sqlalchemy)
- Socket.IO support through [python-socketio](https://github.com/miguelgrinberg/python-socketio)
-
-Do you have other ideas to propose? Let's [discuss them](https://github.com/:miguelgrinberg/microdot/discussions/new?category=ideas)!
--- a/bin/circuitpython
+++ b/bin/circuitpython
--- a/bin/micropython
+++ b/bin/micropython
--- a/docs/_static/css/custom.css
+++ b/docs/_static/css/custom.css
@@ -1,8 +1,3 @@
 .py.class, .py.function, .py.method, .py.property {
  margin-top: 20px;
 }
-
-div.sphinxsidebar {
-    max-height: 100%;
-    overflow-y: auto;
-}
--- a/docs/api.rst
+++ b/docs/api.rst
@@ -1,8 +1,8 @@
 API Reference
 =============

-Core API
--------
+``microdot`` module
+-------------------

 .. autoclass:: microdot.Microdot
   :members:
@@ -13,83 +13,97 @@ Core API
 .. autoclass:: microdot.Response
   :members:

-.. autoclass:: microdot.URLPattern
+.. autoclass:: microdot.NoCaseDict
   :members:

-Multipart Forms
---------------
-
-.. automodule:: microdot.multipart
+.. autoclass:: microdot.MultiDict
   :members:

-WebSocket
---------
+``microdot_asyncio`` module
+---------------------------

-.. automodule:: microdot.websocket
+.. autoclass:: microdot_asyncio.Microdot
+   :inherited-members:
   :members:

-Server-Sent Events (SSE)
+.. autoclass:: microdot_asyncio.Request
+   :inherited-members:
+   :members:
+
+.. autoclass:: microdot_asyncio.Response
+   :inherited-members:
+   :members:
+
+``microdot_utemplate`` module
+-----------------------------
+
+.. automodule:: microdot_utemplate
+   :members:
+
+``microdot_jinja`` module
+-------------------------
+
+.. automodule:: microdot_jinja
+   :members:
+
+``microdot_session`` module
+---------------------------
+
+.. automodule:: microdot_session
+   :members:
+
+``microdot_websocket`` module
+------------------------------
+
+.. automodule:: microdot_websocket
+   :members:
+
+``microdot_asyncio_websocket`` module
+-------------------------------------
+
+.. automodule:: microdot_asyncio_websocket
+   :members:
+
+``microdot_asgi_websocket`` module
+-------------------------------------
+
+.. automodule:: microdot_asgi_websocket
+   :members:
+
+``microdot_ssl`` module
+-----------------------
+
+.. automodule:: microdot_ssl
+   :members:
+
+``microdot_test_client`` module
+-------------------------------
+
+.. autoclass:: microdot_test_client.TestClient
+   :members:
+
+.. autoclass:: microdot_test_client.TestResponse
+   :members:
+
+``microdot_asyncio_test_client`` module
+---------------------------------------
+
+.. autoclass:: microdot_asyncio_test_client.TestClient
+   :members:
+
+.. autoclass:: microdot_asyncio_test_client.TestResponse
+   :members:
+
+``microdot_wsgi`` module
 ------------------------

-.. automodule:: microdot.sse
-   :members:
-
-Templates (uTemplate)
---------------------
-
-.. automodule:: microdot.utemplate
-   :members:
-
-Templates (Jinja)
-----------------
-
-.. automodule:: microdot.jinja
-   :members:
-
-User Sessions
-------------
-
-.. automodule:: microdot.session
-   :members:
-
-Authentication
--------------
-
-.. automodule:: microdot.auth
-   :inherited-members:
-   :special-members: __call__
-   :members:
-
-User Logins
-----------
-
-.. automodule:: microdot.login
-   :inherited-members:
-   :special-members: __call__
-   :members:
-
-Cross-Origin Resource Sharing (CORS)
------------------------------------
-
-.. automodule:: microdot.cors
-   :members:
-
-Test Client
-----------
-
-.. automodule:: microdot.test_client
-   :members:
-
-ASGI
----
-
-.. autoclass:: microdot.asgi.Microdot
+.. autoclass:: microdot_wsgi.Microdot
   :members:
   :exclude-members: shutdown, run

-WSGI
----
+``microdot_asgi`` module
+------------------------

-.. autoclass:: microdot.wsgi.Microdot
+.. autoclass:: microdot_asgi.Microdot
   :members:
   :exclude-members: shutdown, run
--- a/docs/extensions.rst
+++ b/docs/extensions.rst
@@ -2,11 +2,11 @@ Core Extensions
 ---------------

 Microdot is a highly extensible web application framework. The extensions
-described in this section are maintained as part of the Microdot project in
-the same source code repository.
+described in this section are maintained as part of the Microdot project and
+can be obtained from the same source code repository.

-Multipart Forms
-~~~~~~~~~~~~~~~
+Asynchronous Support with Asyncio
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 .. list-table::
   :align: left
@@ -15,197 +15,35 @@ Multipart Forms
     - | CPython & MicroPython

   * - Required Microdot source files
-     -  | `multipart.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot/multipart.py>`_
-        | `helpers.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot/helpers.py>`_
+     - | `microdot.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot.py>`_
+       | `microdot_asyncio.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot_asyncio.py>`_

   * - Required external dependencies
-     - | None
+     - | CPython: None
+       | MicroPython: `uasyncio <https://github.com/micropython/micropython/tree/master/extmod/uasyncio>`_

   * - Examples
-     - | `formdata.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/uploads/formdata.py>`_
+     - | `hello_async.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/hello_async.py>`_

-The multipart extension handles multipart forms, including those that have file
-uploads.
+Microdot can be extended to use an asynchronous programming model based on the
+``asyncio`` package. When the :class:`Microdot <microdot_asyncio.Microdot>`
+class is imported from the ``microdot_asyncio`` package, an asynchronous server
+is used, and handlers can be defined as coroutines.

-The :func:`with_form_data <microdot.multipart.with_form_data>` decorator
-provides the simplest way to work with these forms. With this decorator added
-to the route, whenever the client sends a multipart request the
-:attr:`request.form <microdot.Request.form>` and
-:attr:`request.files <microdot.Request.files>` properties are populated with
-the submitted data. For form fields the field values are always strings. For
-files, they are instances of the
-:class:`FileUpload <microdot.multipart.FileUpload>` class.
+The example that follows uses ``asyncio`` coroutines for concurrency::

-Example::
+    from microdot_asyncio import Microdot

-    from microdot.multipart import with_form_data
+    app = Microdot()

-    @app.post('/upload')
-    @with_form_data
-    async def upload(request):
-        print('form fields:', request.form)
-        print('files:', request.files)
+    @app.route('/')
+    async def hello(request):
+        return 'Hello, world!'

-One disadvantage of the ``@with_form_data`` decorator is that it has to copy
-any uploaded files to memory or temporary disk files, depending on their size.
-The :attr:`FileUpload.max_memory_size <microdot.multipart.FileUpload.max_memory_size>`
-attribute can be used to control the cutoff size above which a file upload
-is transferred to a temporary file.
+    app.run()

-A more performant alternative to the ``@with_form_data`` decorator is the
-:class:`FormDataIter <microdot.multipart.FormDataIter>` class, which iterates
-over the form fields sequentially, giving the application the option to parse
-the form fields on the fly and decide what to copy and what to discard. When
-using ``FormDataIter`` the ``request.form`` and ``request.files`` attributes
-are not used.
-
-Example::
-
-
-    from microdot.multipart import FormDataIter
-
-    @app.post('/upload')
-    async def upload(request):
-        async for name, value in FormDataIter(request):
-            print(name, value)
-
-For fields that contain an uploaded file, the ``value`` returned by the
-iterator is the same ``FileUpload`` instance. The application can choose to
-save the file with the :meth:`save() <microdot.multipart.FileUpload.save>`
-method, or read it with the :meth:`read() <microdot.multipart.FileUpload.read>`
-method, optionally passing a size to read it in chunks. The
-:meth:`copy() <microdot.multipart.FileUpload.copy>` method is also available to
-apply the copying logic used by the ``@with_form_data`` decorator, which is
-inefficient but allows the file to be set aside to be processed later, after
-the remaining form fields.
-
-WebSocket
-~~~~~~~~~
-
-.. list-table::
-   :align: left
-
-   * - Compatibility
-     - | CPython & MicroPython
-
-   * - Required Microdot source files
-     -  | `websocket.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot/websocket.py>`_
-        | `helpers.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot/helpers.py>`_
-
-   * - Required external dependencies
-     - | None
-
-   * - Examples
-     - | `echo.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/websocket/echo.py>`_
-
-The WebSocket extension gives the application the ability to handle WebSocket
-requests. The :func:`with_websocket <microdot.websocket.with_websocket>`
-decorator is used to mark a route handler as a WebSocket handler. Decorated
-routes receive a WebSocket object as a second argument. The WebSocket object
-provides ``send()`` and ``receive()`` asynchronous methods to send and receive
-messages respectively.
-
-Example::
-
-    from microdot.websocket import with_websocket
-
-    @app.route('/echo')
-    @with_websocket
-    async def echo(request, ws):
-        while True:
-            message = await ws.receive()
-            await ws.send(message)
-
-To end the WebSocket connection, the route handler can exit, without returning
-anything::
-
-    @app.route('/echo')
-    @with_websocket
-    async def echo(request, ws):
-        while True:
-            message = await ws.receive()
-            if message == 'exit':
-                break
-            await ws.send(message)
-        await ws.send('goodbye')
-
-If the client ends the WebSocket connection from their side, the route function
-is cancelled. The route function can catch the ``CancelledError`` exception
-from asyncio to perform cleanup tasks::
-
-    @app.route('/echo')
-    @with_websocket
-    async def echo(request, ws):
-        try:
-            while True:
-                message = await ws.receive()
-                await ws.send(message)
-        except asyncio.CancelledError:
-            print('Client disconnected!')
-
-Server-Sent Events
-~~~~~~~~~~~~~~~~~~
-
-.. list-table::
-   :align: left
-
-   * - Compatibility
-     - | CPython & MicroPython
-
-   * - Required Microdot source files
-     -  | `sse.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot/sse.py>`_
-        | `helpers.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot/helpers.py>`_
-
-   * - Required external dependencies
-     - | None
-
-   * - Examples
-     - | `counter.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/sse/counter.py>`_
-
-The Server-Sent Events (SSE) extension simplifies the creation of a streaming
-endpoint that follows the SSE web standard. The :func:`with_sse <microdot.sse.with_sse>`
-decorator is used to mark a route as an SSE handler. Decorated routes receive
-an SSE object as second argument. The SSE object provides a ``send()``
-asynchronous method to send an event to the client.
-
-Example::
-
-    from microdot.sse import with_sse
-
-    @app.route('/events')
-    @with_sse
-    async def events(request, sse):
-        for i in range(10):
-            await asyncio.sleep(1)
-            await sse.send({'counter': i})  # unnamed event
-        await sse.send('end', event='comment')  # named event
-
-To end the SSE connection, the route handler can exit, without returning
-anything, as shown in the above examples.
-
-If the client ends the SSE connection from their side, the route function is
-cancelled. The route function can catch the ``CancelledError`` exception from
-asyncio to perform cleanup tasks::
-
-    @app.route('/events')
-    @with_sse
-    async def events(request, sse):
-        try:
-            i = 0
-            while True:
-                await asyncio.sleep(1)
-                await sse.send({'counter': i})
-                i += 1
-        except asyncio.CancelledError:
-            print('Client disconnected!')
-
-.. note::
-   The SSE protocol is unidirectional, so there is no ``receive()`` method in
-   the SSE object. For bidirectional communication with the client, use the
-   WebSocket extension.
-
-Templates
-~~~~~~~~~
+Rendering HTML Templates
+~~~~~~~~~~~~~~~~~~~~~~~~

 Many web applications use HTML templates for rendering content to clients.
 Microdot includes extensions to render templates with the
@@ -223,57 +61,37 @@ Using the uTemplate Engine
     - | CPython & MicroPython

   * - Required Microdot source files
-     - | `utemplate.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot/utemplate.py>`_
+     - | `microdot.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot.py>`_
+       | `microdot_utemplate.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot_utemplate.py>`_

   * - Required external dependencies
     - | `utemplate <https://github.com/pfalcon/utemplate/tree/master/utemplate>`_

   * - Examples
-     - | `hello.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/templates/utemplate/hello.py>`_
+     - | `hello_utemplate.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/hello_utemplate.py>`_
+       | `hello_utemplate_async.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/hello_utemplate_async.py>`_

-The :class:`Template <microdot.utemplate.Template>` class is used to load a
-template. The argument is the template filename, relative to the templates
-directory, which is *templates* by default.
-
-The ``Template`` object has a :func:`render() <microdot.utemplate.Template.render>`
-method that renders the template to a string. This method receives any
-arguments that are used by the template.
+The :func:`render_template <microdot_utemplate.render_template>` function is
+used to render HTML templates with the uTemplate engine. The first argument is
+the template filename, relative to the templates directory, which is
+*templates* by default. Any additional arguments are passed to the template
+engine to be used as arguments.

 Example::

-    from microdot.utemplate import Template
+    from microdot_utemplate import render_template

    @app.get('/')
-    async def index(req):
-        return Template('index.html').render()
-
-The ``Template`` object also has a :func:`generate() <microdot.utemplate.Template.generate>`
-method, which returns a generator instead of a string. The
-:func:`render_async() <microdot.utemplate.Template.render_async>` and
-:func:`generate_async() <microdot.utemplate.Template.generate_async>` methods
-are the asynchronous versions of these two methods.
+    def index(req):
+        return render_template('index.html')

 The default location from where templates are loaded is the *templates*
 subdirectory. This location can be changed with the
-:func:`Template.initialize <microdot.utemplate.Template.initialize>` class
-method::
+:func:`init_templates <microdot_utemplate.init_templates>` function::

-    Template.initialize('my_templates')
+    from microdot_utemplate import init_templates

-By default templates are automatically compiled the first time they are
-rendered, or when their last modified timestamp is more recent than the
-compiledo file's timestamp. This loading behavior can be changed by switching
-to a different template loader. For example, if the templates are pre-compiled,
-the timestamp check and compile steps can be removed by switching to the
-"compiled" template loader::
-
-    from utemplate import compiled
-    from microdot.utemplate import Template
-
-    Template.initialize(loader_class=compiled.Loader)
-
-Consult the `uTemplate documentation <https://github.com/pfalcon/utemplate>`_
-for additional information regarding template loaders.
+    init_templates('my_templates')

 Using the Jinja Engine
 ^^^^^^^^^^^^^^^^^^^^^^
@@ -285,51 +103,42 @@ Using the Jinja Engine
     - | CPython only

   * - Required Microdot source files
-     - | `jinja.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot/jinja.py>`_
+     - | `microdot.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot.py>`_
+       | `microdot_jinja.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot_jinja.py>`_

   * - Required external dependencies
     - | `Jinja2 <https://jinja.palletsprojects.com/>`_

   * - Examples
-     - | `hello.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/templates/jinja/hello.py>`_
+     - | `hello_jinja.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/hello_jinja.py>`_

-The :class:`Template <microdot.jinja.Template>` class is used to load a
-template. The argument is the template filename, relative to the templates
-directory, which is *templates* by default.
-
-The ``Template`` object has a :func:`render() <microdot.jinja.Template.render>`
-method that renders the template to a string. This method receives any
-arguments that are used by the template.
+The :func:`render_template <microdot_jinja.render_template>` function is used
+to render HTML templates with the Jinja engine. The first argument is the
+template filename, relative to the templates directory, which is *templates* by
+default. Any additional arguments are passed to the template engine to be used
+as arguments.

 Example::

-    from microdot.jinja import Template
+    from microdot_jinja import render_template

    @app.get('/')
-    async def index(req):
-        return Template('index.html').render()
-
-The ``Template`` object also has a :func:`generate() <microdot.jinja.Template.generate>`
-method, which returns a generator instead of a string.
+    def index(req):
+        return render_template('index.html')

 The default location from where templates are loaded is the *templates*
 subdirectory. This location can be changed with the
-:func:`Template.initialize <microdot.jinja.Template.initialize>` class method::
+:func:`init_templates <microdot_jinja.init_templates>` function::

-    Template.initialize('my_templates')
+    from microdot_jinja import init_templates

-The ``initialize()`` method also accepts ``enable_async`` argument, which
-can be set to ``True`` if asynchronous rendering of templates is desired. If
-this option is enabled, then the
-:func:`render_async() <microdot.jinja.Template.render_async>` and
-:func:`generate_async() <microdot.jinja.Template.generate_async>` methods
-must be used.
+    init_templates('my_templates')

 .. note::
    The Jinja extension is not compatible with MicroPython.

-Secure User Sessions
-~~~~~~~~~~~~~~~~~~~~
+Maintaing Secure User Sessions
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 .. list-table::
   :align: left
@@ -338,49 +147,56 @@ Secure User Sessions
     - | CPython & MicroPython

   * - Required Microdot source files
-     - | `session.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot/session.py>`_
-       | `helpers.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot/helpers.py>`_
+     - | `microdot.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot.py>`_
+       | `microdot_session.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot_session.py>`_

   * - Required external dependencies
     - | CPython: `PyJWT <https://pyjwt.readthedocs.io/>`_
       | MicroPython: `jwt.py <https://github.com/micropython/micropython-lib/blob/master/python-ecosys/pyjwt/jwt.py>`_,
-                      `hmac.py <https://github.com/micropython/micropython-lib/blob/master/python-stdlib/hmac/hmac.py>`_
+                      `hmac <https://github.com/micropython/micropython-lib/blob/master/python-stdlib/hmac/hmac.py>`_

   * - Examples
-     - | `login.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/sessions/login.py>`_
+     - | `login.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/login.py>`_

 The session extension provides a secure way for the application to maintain
-user sessions. The session data is stored as a signed cookie in the client's
+user sessions. The session is stored as a signed cookie in the client's
 browser, in `JSON Web Token (JWT) <https://en.wikipedia.org/wiki/JSON_Web_Token>`_
 format.

-To work with user sessions, the application first must configure a secret key
+To work with user sessions, the application first must configure the secret key
 that will be used to sign the session cookies. It is very important that this
-key is kept secret, as its name implies. An attacker who is in possession of
-this key can generate valid user session cookies with any contents.
+key is kept secret. An attacker who is in possession of this key can generate
+valid user session cookies with any contents.

-To initialize the session extension and configure the secret key, create a
-:class:`Session <microdot.session.Session>` object::
+To set the secret key, use the :func:`set_session_secret_key <microdot_session.set_session_secret_key>` function::

-    Session(app, secret_key='top-secret')
+    from microdot_session import set_session_secret_key

-The :func:`with_session <microdot.session.with_session>` decorator is the
-most convenient way to retrieve the session at the start of a request::
+    set_session_secret_key('top-secret!')

-    from microdot import Microdot, redirect
-    from microdot.session import Session, with_session
+To :func:`get_session <microdot_session.get_session>`,
+:func:`update_session <microdot_session.update_session>` and
+:func:`delete_session <microdot_session.delete_session>` functions are used
+inside route handlers to retrieve, store and delete session data respectively.
+The :func:`with_session <microdot_session.with_session>` decorator is provided
+as a convenient way to retrieve the session at the start of a route handler.
+
+Example::
+
+    from microdot import Microdot
+    from microdot_session import set_session_secret_key, with_session, \
+        update_session, delete_session

    app = Microdot()
-    Session(app, secret_key='top-secret')
+    set_session_secret_key('top-secret')

    @app.route('/', methods=['GET', 'POST'])
    @with_session
-    async def index(req, session):
+    def index(req, session):
        username = session.get('username')
        if req.method == 'POST':
            username = req.form.get('username')
-            session['username'] = username
-            session.save()
+            update_session(req, {'username': username})
            return redirect('/')
        if username is None:
            return 'Not logged in'
@@ -388,17 +204,12 @@ most convenient way to retrieve the session at the start of a request::
            return 'Logged in as ' + username

    @app.post('/logout')
-    @with_session
-    async def logout(req, session):
-        session.delete()
+    def logout(req):
+        delete_session(req)
        return redirect('/')

-The :func:`save() <microdot.session.SessionDict.save>` and
-:func:`delete() <microdot.session.SessionDict.delete>` methods are used to update
-and destroy the user session respectively.
-
-Authentication
-~~~~~~~~~~~~~~
+WebSocket Support
+~~~~~~~~~~~~~~~~~

 .. list-table::
   :align: left
@@ -407,111 +218,40 @@ Authentication
     - | CPython & MicroPython

   * - Required Microdot source files
-     - | `auth.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot/auth.py>`_
+     - | `microdot.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot.py>`_
+       | `microdot_websocket.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot_websocket.py>`_

   * - Required external dependencies
     - | None

   * - Examples
-     - | `basic_auth.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/auth/basic_auth.py>`_
-       | `token_auth.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/auth/token_auth.py>`_
+     - | `echo.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/websocket/echo.py>`_
+       | `echo_wsgi.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/websocket/echo_wsgi.py>`_

-The authentication extension provides helper classes for two commonly used
-authentication patterns, described below.
+The WebSocket extension provides a way for the application to handle WebSocket
+requests. The :func:`websocket <microdot_websocket.with_websocket>` decorator
+is used to mark a route handler as a WebSocket handler. The handler receives
+a WebSocket object as a second argument. The WebSocket object provides
+``send()`` and ``receive()`` methods to send and receive messages respectively.

-Basic Authentication
-^^^^^^^^^^^^^^^^^^^^
+Example::

-`Basic Authentication <https://en.wikipedia.org/wiki/Basic_access_authentication>`_
-is a method of authentication that is part of the HTTP specification. It allows
-clients to authenticate to a server using a username and a password. Web
-browsers have native support for Basic Authentication and will automatically
-prompt the user for a username and a password when a protected resource is
-accessed.
+        @app.route('/echo')
+        @with_websocket
+        def echo(request, ws):
+            while True:
+                message = ws.receive()
+                ws.send(message)

-To use Basic Authentication, create an instance of the :class:`BasicAuth <microdot.auth.BasicAuth>`
-class::
+.. note::
+   An unsupported *microsoft_websocket_alt.py* module, with the same
+   interface, is also provided. This module uses the native WebSocket support
+   in MicroPython that powers the WebREPL, and may provide slightly better
+   performance for MicroPython low-end boards. This module is not compatible
+   with CPython.

-    from microdot.auth import BasicAuth
-
-    auth = BasicAuth(app)
-
-Next, create an authentication function. The function must accept a request
-object and a username and password pair provided by the user. If the
-credentials are valid, the function must return an object that represents the
-user. If the authentication function cannot validate the user provided
-credentials it must return ``None``. Decorate the function with
-``@auth.authenticate``::
-
-    @auth.authenticate
-    async def verify_user(request, username, password):
-        user = await load_user_from_database(username)
-        if user and user.verify_password(password):
-            return user
-
-To protect a route with authentication, add the ``auth`` instance as a
-decorator::
-
-    @app.route('/')
-    @auth
-    async def index(request):
-        return f'Hello, {request.g.current_user}!'
-
-While running an authenticated request, the user object returned by the
-authenticaction function is accessible as ``request.g.current_user``.
-
-If an endpoint is intended to work with or without authentication, then it can
-be protected with the ``auth.optional`` decorator::
-
-    @app.route('/')
-    @auth.optional
-    async def index(request):
-        if request.g.current_user:
-            return f'Hello, {request.g.current_user}!'
-        else:
-            return 'Hello, anonymous user!'
-
-As shown in the example, a route can check ``request.g.current_user`` to
-determine if the user is authenticated or not.
-
-Token Authentication
-^^^^^^^^^^^^^^^^^^^^
-
-To set up token authentication, create an instance of
-:class:`TokenAuth <microdot.auth.TokenAuth>`::
-
-    from microdot.auth import TokenAuth
-
-    auth = TokenAuth()
-
-Then add a function that verifies the token and returns the user it belongs to,
-or ``None`` if the token is invalid or expired::
-
-    @auth.authenticate
-    async def verify_token(request, token):
-        return load_user_from_token(token)
-
-As with Basic authentication, the ``auth`` instance is used as a decorator to
-protect your routes, and the authenticated user is accessible from the request
-object as ``request.g.current_user``::
-
-    @app.route('/')
-    @auth
-    async def index(request):
-        return f'Hello, {request.g.current_user}!'
-
-Optional authentication can also be used with tokens::
-
-    @app.route('/')
-    @auth.optional
-    async def index(request):
-        if request.g.current_user:
-            return f'Hello, {request.g.current_user}!'
-        else:
-            return 'Hello, anonymous user!'
-
-User Logins
-~~~~~~~~~~~
+Asynchronous WebSocket
+~~~~~~~~~~~~~~~~~~~~~~

 .. list-table::
   :align: left
@@ -520,84 +260,30 @@ User Logins
     - | CPython & MicroPython

   * - Required Microdot source files
-     - | `login.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot/auth.py>`_
-       | `session.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot/session.py>`_
-       | `helpers.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot/helpers.py>`_
+     - | `microdot.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot.py>`_
+       | `microdot_asyncio.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot_asyncio.py>`_
+       | `microdot_websocket.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot_websocket.py>`_
+       | `microdot_asyncio_websocket.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot_asyncio_websocket.py>`_
+
   * - Required external dependencies
-     - | CPython: `PyJWT <https://pyjwt.readthedocs.io/>`_
-       | MicroPython: `jwt.py <https://github.com/micropython/micropython-lib/blob/master/python-ecosys/pyjwt/jwt.py>`_,
-                      `hmac.py <https://github.com/micropython/micropython-lib/blob/master/python-stdlib/hmac/hmac.py>`_
+     - | CPython: None
+       | MicroPython: `uasyncio <https://github.com/micropython/micropython/tree/master/extmod/uasyncio>`_
+
   * - Examples
-     - | `login.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/login/login.py>`_
+     - | `echo_async.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/websocket/echo_async.py>`_

-The login extension provides user login functionality. The logged in state of
-the user is stored in the user session cookie, and an optional "remember me"
-cookie can also be added to keep the user logged in across browser sessions.
+This extension has the same interface as the synchronous WebSocket extension,
+but the ``receive()`` and ``send()`` methods are asynchronous.

-To use this extension, create instances of the
-:class:`Session <microdot.session.Session>` and :class:`Login <microdot.login.Login>`
-class::
+.. note::
+   An unsupported *microsoft_asgi_websocket.py* module, with the same
+   interface, is also provided. This module must be used instead of
+   *microsoft_asyncio_websocket.py* when the ASGI support is used. The
+   `echo_asgi.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/websocket/echo_asgi.py>`_
+   example shows how to use this module.

-    Session(app, secret_key='top-secret!')
-    login = Login()
-
-The ``Login`` class accept an optional argument with the URL of the login page.
-The default for this URL is */login*.
-
-The application must represent users as objects with an ``id`` attribute. A
-function decorated with ``@login.user_loader`` is used to load a user object::
-
-    @login.user_loader
-    async def get_user(user_id):
-        return database.get_user(user_id)
-
-The application must implement the login form. At the point in which the user
-credentials have been received and verified, a call to the
-:func:`login_user() <microdot.login.Login.login_user>` function must be made to
-record the user in the user session::
-
-    @app.route('/login', methods=['GET', 'POST'])
-    async def login(request):
-        # ...
-        if user.check_password(password):
-            return await login.login_user(request, user, remember=remember_me)
-        return redirect('/login')
-
-The optional ``remember`` argument is used to add a remember me cookie that
-will log the user in automatically in future sessions. A value of ``True`` will
-keep the log in active for 30 days. Alternatively, an integer number of days
-can be passed in this argument.
-
-Any routes that require the user to be logged in must be decorated with
-:func:`@login <microdot.login.Login.__call__>`::
-
-    @app.route('/')
-    @login
-    async def index(request):
-        # ...
-
-Routes that are of a sensitive nature can be decorated with
-:func:`@login.fresh <microdot.login.Login.fresh>`
-instead. This decorator requires that the user has logged in during the current
-session, and will ask the user to logged in again if the session was
-authenticated through a remember me cookie::
-
-    @app.get('/fresh')
-    @login.fresh
-    async def fresh(request):
-        # ...
-
-To log out a user, the :func:`logout_user() <microdot.auth.Login.logout_user>`
-is used::
-
-    @app.post('/logout')
-    @login
-    async def logout(request):
-        await login.logout_user(request)
-        return redirect('/')
-
-Cross-Origin Resource Sharing (CORS)
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+HTTPS Support
+~~~~~~~~~~~~~

 .. list-table::
   :align: left
@@ -606,30 +292,40 @@ Cross-Origin Resource Sharing (CORS)
     - | CPython & MicroPython

   * - Required Microdot source files
-     - | `cors.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot/cors.py>`_
-
-   * - Required external dependencies
-     - | None
+     - | `microdot.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot.py>`_
+       | `microdot_ssl.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot_ssl.py>`_

   * - Examples
-     - | `app.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/cors/app.py>`_
+     - | `hello_tls.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/tls/hello_tls.py>`_
+       | `hello_asyncio_tls.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/tls/hello_asyncio_tls.py>`_

-The CORS extension provides support for `Cross-Origin Resource Sharing
-(CORS) <https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS>`_. CORS is a
-mechanism that allows web applications running on different origins to access
-resources from each other. For example, a web application running on
-``https://example.com`` can access resources from ``https://api.example.com``.
+The ``run()`` function accepts an optional ``ssl`` argument, through which an
+initialized ``SSLContext`` object can be passed. MicroPython does not currently
+have a ``SSLContext`` implementation, so the ``microdot_ssl`` module provides
+a basic implementation that can be used to create a context.

-To enable CORS support, create an instance of the
-:class:`CORS <microdot.cors.CORS>` class and configure the desired options.
 Example::

    from microdot import Microdot
-    from microdot.cors import CORS
+    from microdot_ssl import create_ssl_context

    app = Microdot()
-    cors = CORS(app, allowed_origins=['https://example.com'],
-                allow_credentials=True)
+
+    @app.route('/')
+    def index(req):
+        return 'Hello, World!'
+
+    sslctx = create_ssl_context('cert.der', 'key.der')
+    app.run(port=4443, debug=True, ssl=sslctx)
+
+.. note::
+   The ``microdot_ssl`` module is only needed for MicroPython. When used under
+   CPython, this module creates a standard ``SSLContext`` instance.
+
+.. note::
+   The ``uasyncio`` library for MicroPython does not currently support TLS, so
+   this feature is not available for asynchronous applications on that
+   platform. The ``asyncio`` library for CPython is fully supported.

 Test Client
 ~~~~~~~~~~~
@@ -641,18 +337,19 @@ Test Client
     - | CPython & MicroPython

   * - Required Microdot source files
-     - | `test_client.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot/test_client.py>`_
+     - | `microdot.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot.py>`_
+       | `microdot_test_client.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot_test_client.py>`_

   * - Required external dependencies
     - | None

-The Microdot Test Client is a utility class that can be used in tests to send
-requests into the application without having to start a web server.
+The Microdot Test Client is a utility class that can be used during testing to
+send requests into the application.

 Example::

    from microdot import Microdot
-    from microdot.test_client import TestClient
+    from microdot_test_client import TestClient

    app = Microdot()

@@ -660,67 +357,54 @@ Example::
    def index(req):
        return 'Hello, World!'

-    async def test_app():
+    def test_app():
        client = TestClient(app)
-        response = await client.get('/')
+        response = client.get('/')
        assert response.text == 'Hello, World!'

-See the documentation for the :class:`TestClient <microdot.test_client.TestClient>`
+See the documentation for the :class:`TestClient <microdot_test_client.TestClient>`
 class for more details.

-Production Deployments
-~~~~~~~~~~~~~~~~~~~~~~
-
-The ``Microdot`` class creates its own simple web server. This is enough for an
-application deployed with MicroPython, but when using CPython it may be useful
-to use a separate, battle-tested web server. To address this need, Microdot
-provides extensions that implement the ASGI and WSGI protocols.
-
-Using an ASGI Web Server
-^^^^^^^^^^^^^^^^^^^^^^^^
+Asynchronous Test Client
+~~~~~~~~~~~~~~~~~~~~~~~~

 .. list-table::
   :align: left

   * - Compatibility
-     - | CPython only
+     - | CPython & MicroPython

   * - Required Microdot source files
-     - | `asgi.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot/asgi.py>`_
+     - | `microdot.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot.py>`_
+       | `microdot_asyncio.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot_asyncio.py>`_
+       | `microdot_test_client.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot_test_client.py>`_
+       | `microdot_asyncio_test_client.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot_asyncio_test_client.py>`_

   * - Required external dependencies
-     - | An ASGI web server, such as `Uvicorn <https://www.uvicorn.org/>`_.
+     - | None

-   * - Examples
-     - | `hello_asgi.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/hello/hello_asgi.py>`_
-       | `hello_asgi.py (uTemplate) <https://github.com/miguelgrinberg/microdot/blob/main/examples/templates/utemplate/hello_asgi.py>`_
-       | `hello_asgi.py (Jinja) <https://github.com/miguelgrinberg/microdot/blob/main/examples/templates/jinja/hello_asgi.py>`_
-       | `echo_asgi.py (WebSocket) <https://github.com/miguelgrinberg/microdot/blob/main/examples/websocket/echo_asgi.py>`_
+Similar to the :class:`TestClient <microdot_test_client.TestClient>` class
+above, but for asynchronous applications.

-The ``asgi`` module provides an extended ``Microdot`` class that
-implements the ASGI protocol and can be used with a compliant ASGI server such
-as `Uvicorn <https://www.uvicorn.org/>`_.
+Example usage::

-To use an ASGI web server, the application must import the
-:class:`Microdot <microdot.asgi.Microdot>` class from the ``asgi`` module::
+    from microdot_asyncio_test_client import TestClient

-    from microdot.asgi import Microdot
+    async def test_app():
+        client = TestClient(app)
+        response = await client.get('/')
+        assert response.text == 'Hello, World!'

-    app = Microdot()
+See the :class:`reference documentation <microdot_asyncio_test_client.TestClient>`
+for details.

-    @app.route('/')
-    async def index(req):
-        return 'Hello, World!'
+Deploying on a Production Web Server
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

-The ``app`` application instance created from this class can be used as the
-ASGI callable with any complaint ASGI web server. If the above example
-application was stored in a file called *test.py*, then the following command
-runs the web application using the Uvicorn web server::
-
-    uvicorn test:app
-
-When using the ASGI support, the ``scope`` dictionary provided by the web
-server is available to request handlers as ``request.asgi_scope``.
+The ``Microdot`` class creates its own simple web server. This is enough for an
+application deployed with MicroPython, but when using CPython it may be useful
+to use a separate, battle-tested web server. To address this need, Microdot
+provides extensions that implement the WSGI and ASGI protocols.

 Using a WSGI Web Server
 ^^^^^^^^^^^^^^^^^^^^^^^
@@ -732,27 +416,26 @@ Using a WSGI Web Server
     - | CPython only

   * - Required Microdot source files
-     - | `wsgi.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot/wsgi.py>`_
+     - | `microdot.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot.py>`_
+       | `microdot_wsgi.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot_wsgi.py>`_

   * - Required external dependencies
     - | A WSGI web server, such as `Gunicorn <https://gunicorn.org/>`_.

   * - Examples
-     - | `hello_wsgi.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/hello/hello_wsgi.py>`_
-       | `hello_wsgi.py (uTemplate) <https://github.com/miguelgrinberg/microdot/blob/main/examples/templates/utemplate/hello_wsgi.py>`_
-       | `hello_wsgi.py (Jinja) <https://github.com/miguelgrinberg/microdot/blob/main/examples/templates/jinja/hello_wsgi.py>`_
-       | `echo_wsgi.py (WebSocket) <https://github.com/miguelgrinberg/microdot/blob/main/examples/websocket/echo_wsgi.py>`_
+     - | `hello_wsgi.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/hello_wsgi.py>`_


-The ``wsgi`` module provides an extended ``Microdot`` class that implements the
-WSGI protocol and can be used with a compliant WSGI web server such as 
-`Gunicorn <https://gunicorn.org/>`_ or
+The ``microdot_wsgi`` module provides an extended ``Microdot`` class that
+implements the WSGI protocol and can be used with a compliant WSGI web server
+such as `Gunicorn <https://gunicorn.org/>`_ or
 `uWSGI <https://uwsgi-docs.readthedocs.io/en/latest/>`_.

 To use a WSGI web server, the application must import the
-:class:`Microdot <microdot.wsgi.Microdot>` class from the ``wsgi`` module::
+:class:`Microdot <microdot_wsgi.Microdot>` class from the ``microdot_wsgi``
+module::

-    from microdot.wsgi import Microdot
+    from microdot_wsgi import Microdot

    app = Microdot()

@@ -760,19 +443,53 @@ To use a WSGI web server, the application must import the
    def index(req):
        return 'Hello, World!'

-The ``app`` application instance created from this class can be used as a WSGI
-callbable with any complaint WSGI web server. If the above application
-was stored in a file called *test.py*, then the following command runs the
+The ``app`` application instance created from this class is a WSGI application
+that can be used with any complaint WSGI web server. If the above application
+is stored in a file called *test.py*, then the following command runs the
 web application using the Gunicorn web server::

    gunicorn test:app

-When using the WSGI support, the ``environ`` dictionary provided by the web
-server is available to request handlers as ``request.environ``.
+Using an ASGI Web Server
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. list-table::
+   :align: left
+
+   * - Compatibility
+     - | CPython only
+
+   * - Required Microdot source files
+     - | `microdot.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot.py>`_
+       | `microdot_asyncio.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot_asyncio.py>`_
+       | `microdot_asgi.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot_asgi.py>`_
+
+   * - Required external dependencies
+     - | An ASGI web server, such as `Uvicorn <https://uvicorn.org/>`_.
+
+   * - Examples
+     - | `hello_asgi.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/hello_asgi.py>`_
+
+The ``microdot_asgi`` module provides an extended ``Microdot`` class that
+implements the ASGI protocol and can be used with a compliant ASGI server such
+as `Uvicorn <https://www.uvicorn.org/>`_.
+
+To use an ASGI web server, the application must import the
+:class:`Microdot <microdot_asgi.Microdot>` class from the ``microdot_asgi``
+module::
+
+    from microdot_asgi import Microdot
+
+    app = Microdot()
+
+    @app.route('/')
+    async def index(req):
+        return 'Hello, World!'
+
+The ``app`` application instance created from this class is an ASGI application
+that can be used with any complaint ASGI web server. If the above application
+is stored in a file called *test.py*, then the following command runs the
+web application using the Uvicorn web server::
+
+    uvicorn test:app

-.. note::
-    In spite of WSGI being a synchronous protocol, the Microdot application
-    internally runs under an asyncio event loop. For that reason, the
-    recommendation to prefer ``async def`` handlers over ``def`` still applies
-    under WSGI. Consult the :ref:`Concurrency` section for a discussion of how
-    the two types of functions are handled by Microdot.
--- a/docs/freezing.rst
+++ b/docs/freezing.rst
@@ -1,113 +0,0 @@
-Cross-Compiling and Freezing Microdot
-------------------------------------
-
-.. note::
-   This section only applies when using Microdot on MicroPython.
-
-Microdot is a fairly small framework, so its size is not something you need to
-be concerned about unless you are working with MicroPython on hardware with a
-very small amount of disk space and/or RAM. In such cases every byte counts, so
-this section provides some recommendations on how to keep Microdot's footprint
-as small as possible.
-
-Choosing What Modules to Install
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Microdot has a modular design that allows you to only install the modules that
-your application needs.
-
-For minimal web application support based on the core Microdot web server
-without extensions, you can just copy `microdot.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot/microdot.py>`_
-to the source directory on your device. The core Microdot web server does not
-have any dependencies, so you don't need to install anything else.
-
-If your application uses some of the provided extensions to the core web
-server, then instead of installing *microdot.py* you'll need to create a
-*microdot* subdirectory and install the following files in it:
-
- `__init__.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot/__init__.py>`_
- `microdot.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot/microdot.py>`_
- Any extension modules that you need from the `microdot <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot>`_ source directory.
-
-Some of the extensions also have dependencies of their own, so you may need to
-install those in your device as well (outside of the ``microdot``
-subdirectory). Consult the documentation of each extension to learn if any
-third-party dependencies are required.
-
-Cross-Compiling
-~~~~~~~~~~~~~~~
-
-An issue that is common with low-end microcontroller boards is that they do not
-have enough RAM for the MicroPython compiler to compile the source files, but
-once the code is compiled they are able to run it just fine.
-
-To address this, MicroPython allows you to cross-compile source files on your
-desktop or laptop computer and then upload their compiled versions to the
-device. A good strategy is to cross-compile all the dependencies that are used
-by your application, since these are not going to be updated very often. If the
-goal is to minimize the use of RAM, you can also opt to cross-compile your
-application source files.
-
-The MicroPython cross-compiler is available as a package that you can install
-on standard Python. You must determine the version of MicroPython that you will
-be running on your device, and install the compiler that matches that version.
-For example, if you plan to use MicroPython 1.21.0 on your device, you can
-install the cross-compiler for this version with the following command::
-
-    pip install mpy-cross==1.21.0
-
-Then run the cross-compiler for each source file that you want to compile.
-Since the cross-compilation happens on your computer, you will need to have
-copies of all the source files you need to compile locally on your disk. Here
-is how you can compile the *microdot.py* file, assuming you have a copy in the
-current directory in your computer::
-
-    mpy-cross microdot.py
-
-The cross-compiler will create a file with the same name as the source file,
-but with the extension changed to *.mpy*.
-
-Once you have all your dependencies compiled, you can replace the *.py* files
-in your device with their corresponding *.mpy* versions. MicroPython
-automatically recognizes *.mpy* files, so there is no need to make any changes
-to any source code to start using compiled files.
-
-Freezing
-~~~~~~~~
-
-The ultimate option to reduce the size of a MicroPython application is to
-"freeze" it. Freezing is a process that takes MicroPython source code (either
-dependencies, application code or both), pre-compiles it and incorporates it
-into a custom-built MicroPython firmware that is flashed to the device.
-
-Freezing MicroPython modules to firmware has the advantage that the code is
-imported directly from the device's ROM, leaving more RAM available for
-application use.
-
-The process to create a custom firmware is unfortunately non-trivial and
-different for each microcontroller platform, so you will need to consult the
-MicroPython documentation that applies to your device to learn how to do this.
-
-The part of the process that is common to all devices is the creation of a
-`manifest file <https://docs.micropython.org/en/latest/reference/manifest.html>`_
-to tell the MicroPython firmware builder which packages and modules to freeze.
-
-For a minimal installation of Microdot consisting only in its *microdot.py*
-source file, the manifest file that you need use to build the firmware must
-include the following declaration::
-
-    module('microdot')
-
-If instead you are working with a version of Microdot that includes some or all
-of its extensions, then the manifest file must reference the ``microdot``
-package plus any third-party dependencies that are needed. Below is a manifest
-file for a complete Microdot installation that includes all the extensions::
-
-    package('microdot')
-    package('utemplate')  # required only if templates are used
-    module('pyjwt')       # required only if user sessions are used
-
-In this example, the *microdot* and *utemplate* packages must be available in
-the directory where the manifest file is located so that the MicroPython build
-can find them. The `pyjwt` module is part of the MicroPython standard library
-and will be downloaded as part of the build.
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -9,17 +9,15 @@ Microdot
 *"The impossibly small web framework for Python and MicroPython"*

 Microdot is a minimalistic Python web framework inspired by
-`Flask <https://flask.palletsprojects.com/>`_. Given its size, it can run on
-systems with limited resources such as microcontrollers. Both standard Python
-(CPython) and `MicroPython <https://micropython.org>`_ are supported.
+`Flask <https://flask.palletsprojects.com/>`_, and designed to run on
+systems with limited resources such as microcontrollers. It runs on standard
+Python and on `MicroPython <https://micropython.org>`_.

 .. toctree::
   :maxdepth: 3

   intro
   extensions
-   migrating
-   freezing
   api

 * :ref:`genindex`
--- a/docs/intro.rst
+++ b/docs/intro.rst
--- a/docs/migrating.rst
+++ b/docs/migrating.rst
@@ -1,145 +0,0 @@
-Migrating to Microdot 2.x from Older Releases
---------------------------------------------
-
-Version 2 of Microdot incorporates feedback received from users of earlier
-releases, and attempts to improve and correct some design decisions that have
-proven to be problematic.
-
-For this reason most applications built for earlier versions will need to be
-updated to work correctly with Microdot 2. This section describes the backwards
-incompatible changes that were made.
-
-Code reorganization
-~~~~~~~~~~~~~~~~~~~
-
-The Microdot source code has been moved into a ``microdot`` package,
-eliminating the need for each extension to be named with a *microdot_* prefix.
-
-As a result of this change, all extensions have been renamed to shorter names.
-For example, the *microdot_cors.py* module is now called *cors.py*.
-
-This change affects the way extensions are imported. Instead of this::
-
-    from microdot_cors import CORS
-
-the import statement should be::
-
-    from microdot.cors import CORS
-
-No more synchronous web server
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-In earlier releases of Microdot the core web server was built on synchronous
-Python, and asynchronous support was enabled with the asyncio extension.
-
-Microdot 2 eliminates the synchronous web server, and implements the core
-server logic directly with asyncio, eliminating the need for an asyncio
-extension.
-
-Any applications built using the asyncio extension will need to update their
-imports from this::
-
-    from microdot_asyncio import Microdot
-
-to this::
-
-    from microdot import Microdot
-
-Applications that were built using the synchronous web server do not need to
-change their imports, but will now work asynchronously. Review the
-:ref:`Concurrency` section to learn about the potential issues when using
-``def`` function handlers, and the benefits of transitioning to ``async def``
-handlers.
-
-Removed extensions
-~~~~~~~~~~~~~~~~~~
-
-Some extensions became unnecessary and have been removed or merged with other
-extensions:
-
- *microdot_asyncio.py*: this is now the core web server.
- *microdot_asyncio_websocket.py*: this is now the main WebSocket extension.
- *microdot_asyncio_test_client.py*: this is now the main test client
-  extension.
- *microdot_asgi_websocket.py*: the functionality in this extension is now
-  available in the ASGI extension.
- *microdot_ssl.py*: this extension was only used with the synchronous web
-  server, so it is not needed anymore.
- *microdot_websocket_alt.py*: this extension was only used with the
-  synchronous web server, so it is not needed anymore.
-
-No more ``render_template()`` function
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-The Jinja and uTemplate extensions have been redesigned to work better under
-the asynchronous engine, and as a result, the ``render_template()`` function
-has been eliminated.
-
-Instead of this::
-
-    return render_template('index.html', title='Home')
-
-use this::
-
-    return Template('index.html').render(title='Home')
-
-As a result of this change, it is now possible to use asynchronous rendering::
-
-    return await Template('index.html').render_async(title='Home')
-
-Also thanks to this redesign, the template can be streamed instead of returned
-as a single string::
-
-    return Template('index.html').generate(title='Home')
-
-Streamed templates also have an asynchronous version::
-
-    return Template('index.html').generate_async(title='Home')
-
-Class-based user sessions
-~~~~~~~~~~~~~~~~~~~~~~~~~
-
-The session extension has been completely redesigned. To initialize session
-support for the application, create a ``Session`` object::
-
-    app = Microdot()
-    Session(app, secret_key='top-secret!')
-
-The ``@with_session`` decorator is used to include the session in a request::
-
-    @app.get('/')
-    @with_session
-    async def index(request, session):
-        # ...
-
-The ``session`` can be used as a dictionary to retrieve or change the session.
-To save the session when it has been modified, call its ``save()`` method::
-
-    @app.get('/')
-    @with_session
-    async def index(request, session):
-        # ...
-        session.save()
-        return 'OK'
-
-To delete the session, call its ``delete()`` method before returning from the
-request.
-
-WSGI extension redesign
-~~~~~~~~~~~~~~~~~~~~~~~
-
-Given that the synchronous web server has been removed, the WSGI extension has
-been redesigned to work as a synchronous wrapper for the asynchronous web
-server.
-
-Applications using the WSGI extension continue to run under an asynchronous
-loop and should try to use the recommended ``async def`` handlers, but can be
-deployed with standard WSGI servers such as Gunicorn.
-
-WebSocket support when using the WSGI extension is enabled when using a
-compatible web server. At this time only Gunicorn is supported for WebSocket.
-Given that WebSocket support is asynchronous, it would be better to switch to
-the ASGI extension, which has full support for WebSocket as defined in the ASGI
-specification.
-
-As before, the WSGI extension is not available under MicroPython.
--- a/examples/auth/README.md
+++ b/examples/auth/README.md
@@ -1 +0,0 @@
-This directory contains examples that demonstrate basic and token authentication.
--- a/examples/auth/basic_auth.py
+++ b/examples/auth/basic_auth.py
@@ -1,30 +1,26 @@
 from microdot import Microdot
-from microdot.auth import BasicAuth
-from pbkdf2 import generate_password_hash, check_password_hash
+from microdot_auth import BasicAuth

-
-# this example provides an implementation of the generate_password_hash and
-# check_password_hash functions that can be used in MicroPython. On CPython
-# there are many other options for password hashisng so there is no need to use
-# this custom solution.
-USERS = {
-    'susan': generate_password_hash('hello'),
-    'david': generate_password_hash('bye'),
-}
 app = Microdot()
-auth = BasicAuth()
+basic_auth = BasicAuth()
+
+USERS = {
+    'susan': 'hello',
+    'david': 'bye',
+}


-@auth.authenticate
-async def check_credentials(request, username, password):
-    if username in USERS and check_password_hash(USERS[username], password):
-        return username
+@basic_auth.callback
+def verify_password(request, username, password):
+    if username in USERS and USERS[username] == password:
+        request.g.user = username
+        return True


@app.route('/')
-@auth
-async def index(request):
-    return f'Hello, {request.g.current_user}!'
+@basic_auth
+def index(request):
+    return f'Hello, {request.g.user}!'


 if __name__ == '__main__':
--- a/examples/auth/login_auth.py
+++ b/examples/auth/login_auth.py
@@ -0,0 +1,60 @@
+from microdot import Microdot, redirect
+from microdot_session import set_session_secret_key
+from microdot_login import LoginAuth
+
+app = Microdot()
+set_session_secret_key('top-secret')
+login_auth = LoginAuth()
+
+USERS = {
+    'susan': 'hello',
+    'david': 'bye',
+}
+
+
+@login_auth.callback
+def check_user(request, user_id):
+    request.g.user = user_id
+    return True
+
+
+@app.route('/')
+@login_auth
+def index(request):
+    return f'''
+        <h1>Login Auth Example</h1>
+        <p>Hello, {request.g.user}!</p>
+        <form method="POST" action="/logout">
+            <button type="submit">Logout</button>
+        </form>
+    ''', {'Content-Type': 'text/html'}
+
+
+@app.route('/login', methods=['GET', 'POST'])
+def login(request):
+    if request.method == 'GET':
+        return '''
+            <h1>Login Auth Example</h1>
+            <form method="POST">
+                <input name="username" placeholder="username">
+                <input name="password" type="password" placeholder="password">
+                <button type="submit">Login</button>
+            </form>
+        ''', {'Content-Type': 'text/html'}
+    username = request.form['username']
+    password = request.form['password']
+    if USERS.get(username) == password:
+        login_auth.login_user(request, username)
+        return login_auth.redirect_to_next(request)
+    else:
+        return redirect('/login')
+
+
+@app.post('/logout')
+def logout(request):
+    login_auth.logout_user(request)
+    return redirect('/')
+
+
+if __name__ == '__main__':
+    app.run(debug=True)
--- a/examples/auth/pbkdf2.py
+++ b/examples/auth/pbkdf2.py
@@ -1,47 +0,0 @@
-import os
-import hashlib
-
-# PBKDF2 secure password hashing algorithm obtained from:
-# https://codeandlife.com/2023/01/06/how-to-calculate-pbkdf2-hmac-sha256-with-
-# python,-example-code/
-
-
-def sha256(b):
-    return hashlib.sha256(b).digest()
-
-
-def ljust(b, n, f):
-    return b + f * (n - len(b))
-
-
-def gethmac(key, content):
-    okeypad = bytes(v ^ 0x5c for v in ljust(key, 64, b'\0'))
-    ikeypad = bytes(v ^ 0x36 for v in ljust(key, 64, b'\0'))
-    return sha256(okeypad + sha256(ikeypad + content))
-
-
-def pbkdf2(pwd, salt, iterations=1000):
-    U = salt + b'\x00\x00\x00\x01'
-    T = bytes(64)
-    for _ in range(iterations):
-        U = gethmac(pwd, U)
-        T = bytes(a ^ b for a, b in zip(U, T))
-    return T
-
-
-# The number of iterations may need to be adjusted depending on the hardware.
-# Lower numbers make the password hashing algorithm faster but less secure, so
-# the largest number that can be tolerated should be used.
-def generate_password_hash(password, salt=None, iterations=100000):
-    salt = salt or os.urandom(16)
-    dk = pbkdf2(password.encode(), salt, iterations)
-    return f'pbkdf2-hmac-sha256:{salt.hex()}:{iterations}:{dk.hex()}'
-
-
-def check_password_hash(password_hash, password):
-    algorithm, salt, iterations, dk = password_hash.split(':')
-    iterations = int(iterations)
-    if algorithm != 'pbkdf2-hmac-sha256':
-        return False
-    return pbkdf2(password.encode(), salt=bytes.fromhex(salt),
-                  iterations=iterations) == bytes.fromhex(dk)
--- a/examples/auth/token_auth.py
+++ b/examples/auth/token_auth.py
@@ -1,25 +1,26 @@
 from microdot import Microdot
-from microdot.auth import TokenAuth
+from microdot_auth import TokenAuth

 app = Microdot()
-auth = TokenAuth()
+token_auth = TokenAuth()

 TOKENS = {
-    'susan-token': 'susan',
-    'david-token': 'david',
+    'hello': 'susan',
+    'bye': 'david',
 }


-@auth.authenticate
-async def check_token(request, token):
+@token_auth.callback
+def verify_token(request, token):
    if token in TOKENS:
-        return TOKENS[token]
+        request.g.user = TOKENS[token]
+        return True


@app.route('/')
-@auth
-async def index(request):
-    return f'Hello, {request.g.current_user}!'
+@token_auth
+def index(request):
+    return f'Hello, {request.g.user}!'


 if __name__ == '__main__':
--- a/examples/benchmark/mem.py
+++ b/examples/benchmark/mem.py
@@ -4,7 +4,7 @@ app = Microdot()


@app.get('/')
-async def index(req):
+def index(req):
    return {'hello': 'world'}


--- a/examples/benchmark/mem_asgi.py
+++ b/examples/benchmark/mem_asgi.py
@@ -1,4 +1,4 @@
-from microdot.asgi import Microdot
+from microdot_asgi import Microdot

 app = Microdot()

--- a/examples/benchmark/mem_async.py
+++ b/examples/benchmark/mem_async.py
@@ -0,0 +1,11 @@
+from microdot_asyncio import Microdot
+
+app = Microdot()
+
+
+@app.get('/')
+async def index(req):
+    return {'hello': 'world'}
+
+
+app.run()
--- a/examples/benchmark/mem_fastapi.py
+++ b/examples/benchmark/mem_fastapi.py
@@ -4,5 +4,5 @@ app = FastAPI()


@app.get('/')
-async def index():
+def index():
    return {'hello': 'world'}
--- a/examples/benchmark/mem_quart.py
+++ b/examples/benchmark/mem_quart.py
@@ -4,5 +4,5 @@ app = Quart(__name__)


@app.get('/')
-async def index():
+def index():
    return {'hello': 'world'}
--- a/examples/benchmark/mem_wsgi.py
+++ b/examples/benchmark/mem_wsgi.py
@@ -1,4 +1,4 @@
-from microdot.wsgi import Microdot
+from microdot_wsgi import Microdot

 app = Microdot()

--- a/examples/benchmark/requirements.in
+++ b/examples/benchmark/requirements.in
@@ -1,9 +0,0 @@
-pip-tools
-flask
-quart
-fastapi
-gunicorn
-uvicorn
-requests
-psutil
-humanize
--- a/examples/benchmark/requirements.txt
+++ b/examples/benchmark/requirements.txt
@@ -1,113 +1,33 @@
-#
-# This file is autogenerated by pip-compile with Python 3.12
-# by the following command:
-#
-#    pip-compile requirements.in
-#
-aiofiles==23.2.1
-    # via quart
-annotated-types==0.6.0
-    # via pydantic
-anyio==3.7.1
-    # via starlette
-blinker==1.7.0
-    # via
-    #   flask
-    #   quart
-build==1.0.3
-    # via pip-tools
-certifi==2024.7.4
-    # via requests
-charset-normalizer==3.3.2
-    # via requests
-click==8.1.7
-    # via
-    #   flask
-    #   pip-tools
-    #   quart
-    #   uvicorn
-fastapi==0.109.1
-    # via -r requirements.in
-flask==3.0.0
-    # via
-    #   -r requirements.in
-    #   quart
-gunicorn==23.0.0
-    # via -r requirements.in
-h11==0.16.0
-    # via
-    #   hypercorn
-    #   uvicorn
-    #   wsproto
+aiofiles==0.8.0
+anyio==3.6.1
+blinker==1.5
+certifi==2022.6.15
+charset-normalizer==2.1.0
+click==8.1.3
+fastapi==0.79.0
+Flask==2.2.1
+gunicorn==20.1.0
+h11==0.13.0
 h2==4.1.0
-    # via hypercorn
 hpack==4.0.0
-    # via h2
-humanize==4.9.0
-    # via -r requirements.in
-hypercorn==0.15.0
-    # via quart
+humanize==4.3.0
+hypercorn==0.13.2
 hyperframe==6.0.1
-    # via h2
-idna==3.7
-    # via
-    #   anyio
-    #   requests
+idna==3.3
 itsdangerous==2.1.2
-    # via
-    #   flask
-    #   quart
-jinja2==3.1.6
-    # via
-    #   flask
-    #   quart
-markupsafe==2.1.3
-    # via
-    #   jinja2
-    #   quart
-    #   werkzeug
-packaging==23.2
-    # via
-    #   build
-    #   gunicorn
-pip-tools==7.3.0
-    # via -r requirements.in
+Jinja2==3.1.2
+MarkupSafe==2.1.1
+microdot
 priority==2.0.0
-    # via hypercorn
-psutil==5.9.6
-    # via -r requirements.in
-pydantic==2.5.2
-    # via fastapi
-pydantic-core==2.14.5
-    # via pydantic
-pyproject-hooks==1.0.0
-    # via build
-quart==0.20.0
-    # via -r requirements.in
-requests==2.32.4
-    # via -r requirements.in
-sniffio==1.3.0
-    # via anyio
-starlette==0.35.1
-    # via fastapi
-typing-extensions==4.9.0
-    # via
-    #   fastapi
-    #   pydantic
-    #   pydantic-core
-urllib3==2.5.0
-    # via requests
-uvicorn==0.24.0.post1
-    # via -r requirements.in
-werkzeug==3.0.6
-    # via
-    #   flask
-    #   quart
-wheel==0.42.0
-    # via pip-tools
-wsproto==1.2.0
-    # via hypercorn
-
-# The following packages are considered to be unsafe in a requirements file:
-# pip
-# setuptools
+psutil==5.9.1
+pydantic==1.9.1
+quart==0.18.0
+requests==2.28.1
+sniffio==1.2.0
+starlette==0.19.1
+toml==0.10.2
+typing_extensions==4.3.0
+urllib3==1.26.11
+uvicorn==0.18.2
+Werkzeug==2.2.1
+wsproto==1.1.0
--- a/examples/benchmark/results.txt
+++ b/examples/benchmark/results.txt
@@ -0,0 +1,14 @@
+❯ curl -X GET http://localhost:5000/        <-- microdot
+{"ram": 8429568}%
+❯ curl -X GET http://localhost:5000/        <-- microdot_asyncio
+{"ram": 12410880}%
+❯ curl -X GET http://localhost:8000/        <-- microdot_wsgi
+{"ram": 9101312}%
+❯ curl -X GET http://localhost:8000/        <-- microdot_asgi
+{"ram": 18620416}%
+❯ curl -X GET http://localhost:5000/        <-- flask app.run
+{"ram":25460736}
+❯ curl -X GET http://localhost:5000/        <-- flask run
+{"ram":26210304}
+❯ curl -X GET http://localhost:5000/        <-- quart run
+{"ram":31748096}%
--- a/examples/benchmark/run.py
+++ b/examples/benchmark/run.py
@@ -1,7 +1,6 @@
 import os
 import subprocess
 import time
-from timeit import timeit
 import requests
 import psutil
 import humanize
@@ -14,8 +13,13 @@ apps = [
    ),
    (
        'micropython mem.py',
+        {'MICROPYPATH': '../../src'},
+        'microdot-micropython-sync'
+    ),
+    (
+        'micropython mem_async.py',
        {'MICROPYPATH': '../../src:../../libs/micropython'},
-        'microdot-micropython'
+        'microdot-micropython-async'
    ),
    (
        ['python', '-c', 'import time; time.sleep(10)'],
@@ -25,65 +29,66 @@ apps = [
    (
        'python mem.py',
        {'PYTHONPATH': '../../src'},
-        'microdot-cpython'
+        'microdot-cpython-sync'
    ),
    (
-        'uvicorn --workers 1 --port 5000 mem_asgi:app',
+        'python mem_async.py',
        {'PYTHONPATH': '../../src'},
-        'microdot-uvicorn'
+        'microdot-cpython-async'
    ),
    (
        'gunicorn --workers 1 --bind :5000 mem_wsgi:app',
        {'PYTHONPATH': '../../src'},
-        'microdot-gunicorn'
+        'microdot-gunicorn-sync'
+    ),
+    (
+        'uvicorn --workers 1 --port 5000 mem_asgi:app',
+        {'PYTHONPATH': '../../src'},
+        'microdot-uvicorn-async'
    ),
    (
        'flask run',
        {'FLASK_APP': 'mem_flask.py'},
-        'flask-run'
+        'flask-run-sync'
    ),
    (
        'quart run',
        {'QUART_APP': 'mem_quart.py'},
-        'quart-run'
+        'quart-run-async'
    ),
    (
        'gunicorn --workers 1 --bind :5000 mem_flask:app',
        {},
-        'flask-gunicorn'
+        'flask-gunicorn-sync'
    ),
    (
        'uvicorn --workers 1 --port 5000 mem_quart:app',
        {},
-        'quart-uvicorn'
+        'quart-uvicorn-async'
    ),
    (
        'uvicorn --workers 1 --port 5000 mem_fastapi:app',
        {},
-        'fastapi-uvicorn'
+        'fastapi-uvicorn-async'
    ),
 ]

 for app, env, name in apps:
    p = subprocess.Popen(
        app.split() if isinstance(app, str) else app,
-        env={'PATH': os.environ['PATH'] + ':../../bin', **env},
+        env={'PATH': os.environ['PATH'], **env},
        stdout=subprocess.DEVNULL,
        stderr=subprocess.DEVNULL
    )
    time.sleep(1)
-    tm = 0
    if not name.startswith('baseline'):
-        def req():
-            r = requests.get('http://localhost:5000')
-            r.raise_for_status()
-
-        tm = timeit(req, number=1000)
+        r = requests.get('http://localhost:5000')
+        r.raise_for_status()
    proc = psutil.Process(p.pid)
    mem = proc.memory_info().rss
    for child in proc.children(recursive=True):
        mem += child.memory_info().rss
    bar = '*' * (mem // (1024 * 1024))
-    print(f'{name:<28}{tm:10.2f}s {humanize.naturalsize(mem):>10} {bar}')
+    print(f'{name:<28}{humanize.naturalsize(mem):>10} {bar}')
    p.terminate()
    time.sleep(1)
--- a/examples/cors/README.md
+++ b/examples/cors/README.md
@@ -1 +0,0 @@
-This directory contains Cross-Origin Resource Sharing (CORS) examples.
--- a/examples/cors/app.py
+++ b/examples/cors/app.py
@@ -1,14 +0,0 @@
-from microdot import Microdot
-from microdot.cors import CORS
-
-app = Microdot()
-CORS(app, allowed_origins=['https://example.org'], allow_credentials=True)
-
-
-@app.route('/')
-def index(request):
-    return 'Hello World!'
-
-
-if __name__ == '__main__':
-    app.run()
--- a/examples/gpio/gpio.html
+++ b/examples/gpio/gpio.html
@@ -2,7 +2,6 @@
 <html>
    <head>
        <title>Microdot GPIO Example</title>
-        <meta charset="UTF-8">
        <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/css/bootstrap.min.css" integrity="sha384-ggOyR0iXCbMQv3Xipma34MD+dH/1fQ784/j6cY/iJTQUOhcWr7x9JvoRxT2MZw1T" crossorigin="anonymous">
        <script>
            function getCookie(name) {
--- a/examples/hello/hello.py
+++ b/examples/hello/hello.py
@@ -2,11 +2,10 @@ from microdot import Microdot

 app = Microdot()

-html = '''<!DOCTYPE html>
+htmldoc = '''<!DOCTYPE html>
 <html>
    <head>
        <title>Microdot Example Page</title>
-        <meta charset="UTF-8">
    </head>
    <body>
        <div>
@@ -20,12 +19,12 @@ html = '''<!DOCTYPE html>


@app.route('/')
-async def hello(request):
-    return html, 200, {'Content-Type': 'text/html'}
+def hello(request):
+    return htmldoc, 200, {'Content-Type': 'text/html'}


@app.route('/shutdown')
-async def shutdown(request):
+def shutdown(request):
    request.app.shutdown()
    return 'The server is shutting down...'

--- a/examples/hello/hello_asgi.py
+++ b/examples/hello/hello_asgi.py
@@ -1,12 +1,11 @@
-from microdot.asgi import Microdot
+from microdot_asgi import Microdot

 app = Microdot()

-html = '''<!DOCTYPE html>
+htmldoc = '''<!DOCTYPE html>
 <html>
    <head>
        <title>Microdot Example Page</title>
-        <meta charset="UTF-8">
    </head>
    <body>
        <div>
@@ -21,7 +20,7 @@ html = '''<!DOCTYPE html>

@app.route('/')
 async def hello(request):
-    return html, 200, {'Content-Type': 'text/html'}
+    return htmldoc, 200, {'Content-Type': 'text/html'}


@app.route('/shutdown')
--- a/examples/hello/hello_async.py
+++ b/examples/hello/hello_async.py
@@ -0,0 +1,32 @@
+from microdot_asyncio import Microdot
+
+app = Microdot()
+
+htmldoc = '''<!DOCTYPE html>
+<html>
+    <head>
+        <title>Microdot Example Page</title>
+    </head>
+    <body>
+        <div>
+            <h1>Microdot Example Page</h1>
+            <p>Hello from Microdot!</p>
+            <p><a href="/shutdown">Click to shutdown the server</a></p>
+        </div>
+    </body>
+</html>
+'''
+
+
+@app.route('/')
+async def hello(request):
+    return htmldoc, 200, {'Content-Type': 'text/html'}
+
+
+@app.route('/shutdown')
+async def shutdown(request):
+    request.app.shutdown()
+    return 'The server is shutting down...'
+
+
+app.run(debug=True)
--- a/examples/templates/jinja/streaming.py
+++ b/examples/templates/jinja/streaming.py
@@ -1,16 +1,16 @@
 from microdot import Microdot, Response
-from microdot.jinja import Template
+from microdot_jinja import render_template

 app = Microdot()
 Response.default_content_type = 'text/html'


@app.route('/', methods=['GET', 'POST'])
-async def index(req):
+def index(req):
    name = None
    if req.method == 'POST':
        name = req.form.get('name')
-    return Template('index.html').generate(name=name)
+    return render_template('index_jinja.html', name=name)


 if __name__ == '__main__':
--- a/examples/templates/utemplate/streaming.py
+++ b/examples/templates/utemplate/streaming.py
@@ -1,16 +1,16 @@
 from microdot import Microdot, Response
-from microdot.utemplate import Template
+from microdot_utemplate import render_template

 app = Microdot()
 Response.default_content_type = 'text/html'


@app.route('/', methods=['GET', 'POST'])
-async def index(req):
+def index(req):
    name = None
    if req.method == 'POST':
        name = req.form.get('name')
-    return Template('index.html').generate(name=name)
+    return render_template('index_utemplate.html', name=name)


 if __name__ == '__main__':
--- a/examples/hello/hello_utemplate_async.py
+++ b/examples/hello/hello_utemplate_async.py
@@ -1,5 +1,5 @@
-from microdot.asgi import Microdot, Response
-from microdot.jinja import Template
+from microdot_asyncio import Microdot, Response
+from microdot_utemplate import render_template

 app = Microdot()
 Response.default_content_type = 'text/html'
@@ -10,7 +10,7 @@ async def index(req):
    name = None
    if req.method == 'POST':
        name = req.form.get('name')
-    return Template('index.html').render(name=name)
+    return render_template('index.html', name=name)


 if __name__ == '__main__':
--- a/examples/hello/hello_wsgi.py
+++ b/examples/hello/hello_wsgi.py
@@ -1,12 +1,11 @@
-from microdot.wsgi import Microdot
+from microdot_wsgi import Microdot

 app = Microdot()

-html = '''<!DOCTYPE html>
+htmldoc = '''<!DOCTYPE html>
 <html>
    <head>
        <title>Microdot Example Page</title>
-        <meta charset="UTF-8">
    </head>
    <body>
        <div>
@@ -21,7 +20,7 @@ html = '''<!DOCTYPE html>

@app.route('/')
 def hello(request):
-    return html, 200, {'Content-Type': 'text/html'}
+    return htmldoc, 200, {'Content-Type': 'text/html'}


@app.route('/shutdown')
--- a/examples/templates/jinja/templates/index.html
+++ b/examples/templates/jinja/templates/index.html
@@ -2,7 +2,6 @@
 <html>
  <head>
    <title>Microdot + Jinja example</title>
-    <meta charset="UTF-8">
  </head>
  <body>
    <h1>Microdot + Jinja example</h1>
--- a/examples/templates/utemplate/templates/index.html
+++ b/examples/templates/utemplate/templates/index.html
@@ -3,7 +3,6 @@
 <html>
  <head>
    <title>Microdot + uTemplate example</title>
-    <meta charset="UTF-8">
  </head>
  <body>
    <h1>Microdot + uTemplate example</h1>
--- a/examples/login/README.md
+++ b/examples/login/README.md
@@ -1 +0,0 @@
-This directory contains examples that demonstrate user logins.
--- a/examples/login/login.py
+++ b/examples/login/login.py
@@ -1,123 +0,0 @@
-from microdot import Microdot, redirect
-from microdot.session import Session
-from microdot.login import Login
-from pbkdf2 import generate_password_hash, check_password_hash
-
-# this example provides an implementation of the generate_password_hash and
-# check_password_hash functions that can be used in MicroPython. On CPython
-# there are many other options for password hashisng so there is no need to use
-# this custom solution.
-
-
-class User:
-    def __init__(self, id, username, password):
-        self.id = id
-        self.username = username
-        self.password_hash = self.create_hash(password)
-
-    def create_hash(self, password):
-        return generate_password_hash(password)
-
-    def check_password(self, password):
-        return check_password_hash(self.password_hash, password)
-
-
-USERS = {
-    'user001': User('user001', 'susan', 'hello'),
-    'user002': User('user002', 'david', 'bye'),
-}
-
-app = Microdot()
-Session(app, secret_key='top-secret!')
-login = Login()
-
-
-@login.user_loader
-async def get_user(user_id):
-    return USERS.get(user_id)
-
-
-@app.route('/login', methods=['GET', 'POST'])
-async def login_page(request):
-    if request.method == 'GET':
-        return '''
-            <!doctype html>
-            <html>
-              <body>
-                <h1>Please Login</h1>
-                <form method="POST">
-                  <p>
-                    Username<br>
-                    <input name="username" autofocus>
-                  </p>
-                  <p>
-                    Password:<br>
-                    <input name="password" type="password">
-                    <br>
-                  </p>
-                  <p>
-                    <input name="remember_me" type="checkbox"> Remember me
-                    <br>
-                  </p>
-                  <p>
-                    <button type="submit">Login</button>
-                  </p>
-                </form>
-              </body>
-            </html>
-        ''', {'Content-Type': 'text/html'}
-    username = request.form['username']
-    password = request.form['password']
-    remember_me = bool(request.form.get('remember_me'))
-
-    for user in USERS.values():
-        if user.username == username:
-            if user.check_password(password):
-                return await login.login_user(request, user,
-                                              remember=remember_me)
-    return redirect('/login')
-
-
-@app.route('/')
-@login
-async def index(request):
-    return f'''
-        <!doctype html>
-        <html>
-          <body>
-            <h1>Hello, {request.g.current_user.username}!</h1>
-            <p>
-              <a href="/fresh">Click here</a> to access the fresh login page.
-            </p>
-            <form method="POST" action="/logout">
-              <button type="submit">Logout</button>
-            </form>
-          </body>
-        </html>
-    ''', {'Content-Type': 'text/html'}
-
-
-@app.get('/fresh')
-@login.fresh
-async def fresh(request):
-    return f'''
-        <!doctype html>
-        <html>
-          <body>
-            <h1>Hello, {request.g.current_user.username}!</h1>
-            <p>This page requires a fresh login session.</p>
-            <p><a href="/">Go back</a> to the main page.</p>
-          </body>
-        </html>
-    ''', {'Content-Type': 'text/html'}
-
-
-@app.post('/logout')
-@login
-async def logout(request):
-    await login.logout_user(request)
-    return redirect('/')
-
-
-if __name__ == '__main__':
-    app.run(debug=True)
--- a/examples/login/pbkdf2.py
+++ b/examples/login/pbkdf2.py
@@ -1,47 +0,0 @@
-import os
-import hashlib
-
-# PBKDF2 secure password hashing algorithm obtained from:
-# https://codeandlife.com/2023/01/06/how-to-calculate-pbkdf2-hmac-sha256-with-
-# python,-example-code/
-
-
-def sha256(b):
-    return hashlib.sha256(b).digest()
-
-
-def ljust(b, n, f):
-    return b + f * (n - len(b))
-
-
-def gethmac(key, content):
-    okeypad = bytes(v ^ 0x5c for v in ljust(key, 64, b'\0'))
-    ikeypad = bytes(v ^ 0x36 for v in ljust(key, 64, b'\0'))
-    return sha256(okeypad + sha256(ikeypad + content))
-
-
-def pbkdf2(pwd, salt, iterations=1000):
-    U = salt + b'\x00\x00\x00\x01'
-    T = bytes(64)
-    for _ in range(iterations):
-        U = gethmac(pwd, U)
-        T = bytes(a ^ b for a, b in zip(U, T))
-    return T
-
-
-# The number of iterations may need to be adjusted depending on the hardware.
-# Lower numbers make the password hashing algorithm faster but less secure, so
-# the largest number that can be tolerated should be used.
-def generate_password_hash(password, salt=None, iterations=100000):
-    salt = salt or os.urandom(16)
-    dk = pbkdf2(password.encode(), salt, iterations)
-    return f'pbkdf2-hmac-sha256:{salt.hex()}:{iterations}:{dk.hex()}'
-
-
-def check_password_hash(password_hash, password):
-    algorithm, salt, iterations, dk = password_hash.split(':')
-    iterations = int(iterations)
-    if algorithm != 'pbkdf2-hmac-sha256':
-        return False
-    return pbkdf2(password.encode(), salt=bytes.fromhex(salt),
-                  iterations=iterations) == bytes.fromhex(dk)
--- a/examples/sessions/login.py
+++ b/examples/sessions/login.py
@@ -1,14 +1,11 @@
-# This is a simple example that demonstrates how to use the user session, but
-# is not intended as a complete login solution. See the login subdirectory for
-# a more complete example.
 from microdot import Microdot, Response, redirect
-from microdot.session import Session, with_session
+from microdot_session import set_session_secret_key, with_session, \
+    update_session, delete_session

 BASE_TEMPLATE = '''<!doctype html>
 <html>
  <head>
    <title>Microdot login example</title>
-    <meta charset="UTF-8">
  </head>
  <body>
    <h1>Microdot login example</h1>
@@ -20,7 +17,7 @@ LOGGED_OUT = '''<p>You are not logged in.</p>
 <form method="POST">
  <p>
    Username:
-    <input name="username" autofocus />
+    <input type="text" name="username" autofocus />
  </p>
  <input type="submit" value="Submit" />
 </form>'''
@@ -31,19 +28,18 @@ LOGGED_IN = '''<p>Hello <b>{username}</b>!</p>
 </form>'''

 app = Microdot()
-Session(app, secret_key='top-secret')
+set_session_secret_key('top-secret')
 Response.default_content_type = 'text/html'


@app.get('/')
@app.post('/')
@with_session
-async def index(req, session):
+def index(req, session):
    username = session.get('username')
    if req.method == 'POST':
        username = req.form.get('username')
-        session['username'] = username
-        session.save()
+        update_session(req, {'username': username})
        return redirect('/')
    if username is None:
        return BASE_TEMPLATE.format(content=LOGGED_OUT)
@@ -53,9 +49,8 @@ async def index(req, session):


@app.post('/logout')
-@with_session
-async def logout(req, session):
-    session.delete()
+def logout(req):
+    delete_session(req)
    return redirect('/')


--- a/examples/sse/counter.py
+++ b/examples/sse/counter.py
@@ -1,28 +0,0 @@
-import asyncio
-from microdot import Microdot, send_file
-from microdot.sse import with_sse
-
-app = Microdot()
-
-
-@app.route("/")
-async def main(request):
-    return send_file('index.html')
-
-
-@app.route('/events')
-@with_sse
-async def events(request, sse):
-    print('Client connected')
-    try:
-        i = 0
-        while True:
-            await asyncio.sleep(1)
-            i += 1
-            await sse.send({'counter': i})
-    except asyncio.CancelledError:
-        pass
-    print('Client disconnected')
-
-
-app.run()
--- a/examples/sse/index.html
+++ b/examples/sse/index.html
@@ -1,30 +0,0 @@
-<!DOCTYPE html>
-<html>
-  <head>
-    <title>Microdot SSE Example</title>
-    <meta charset="UTF-8">
-  </head>
-  <body>
-    <h1>Microdot SSE Example</h1>
-    <div id="log"></div>
-    <script>
-      const log = (text, color) => {
-        document.getElementById('log').innerHTML += `<span style="color: ${color}">${text}</span><br>`;
-      };
-
-      const eventSource = new EventSource('/events');
-
-      eventSource.onopen = () => {
-        log('Connection to server opened.', 'black');
-      };
-
-      eventSource.onmessage = (event) => {
-        log(`Received message: ${event.data}`, 'blue');
-      };
-
-      eventSource.onerror = (event) => {
-        log(`EventSource failed: ${event.type}`, 'red');
-      };
-    </script>
-  </body>
-</html>
--- a/examples/static/gzstatic.py
+++ b/examples/static/gzstatic.py
@@ -1,20 +0,0 @@
-from microdot import Microdot, send_file
-
-app = Microdot()
-
-
-@app.route('/')
-def index(request):
-    return send_file('gzstatic/index.html', compressed=True,
-                     file_extension='.gz')
-
-
-@app.route('/static/<path:path>')
-def static(request, path):
-    if '..' in path:
-        # directory traversal is not allowed
-        return 'Not found', 404
-    return send_file('gzstatic/' + path, compressed=True, file_extension='.gz')
-
-
-app.run(debug=True)
--- a/examples/static/gzstatic/index.html.gz
+++ b/examples/static/gzstatic/index.html.gz
--- a/examples/static/gzstatic/logo.png.gz
+++ b/examples/static/gzstatic/logo.png.gz
--- a/examples/static/static.py
+++ b/examples/static/static.py
@@ -1,14 +1,15 @@
 from microdot import Microdot, send_file
+
 app = Microdot()


@app.route('/')
-async def index(request):
+def index(request):
    return send_file('static/index.html')


@app.route('/static/<path:path>')
-async def static(request, path):
+def static(request, path):
    if '..' in path:
        # directory traversal is not allowed
        return 'Not found', 404
--- a/examples/static/static/index.css
+++ b/examples/static/static/index.css
@@ -1,10 +0,0 @@
-p {
-  font-family: Arial, Helvetica, sans-serif;
-  color: #333333;
-}
-
-h1 {
-  font-family: Arial, Helvetica, sans-serif;
-  color: #3070b3;
-  text-align: center;
-}
--- a/examples/static/static/index.html
+++ b/examples/static/static/index.html
@@ -2,7 +2,6 @@
 <html>
  <head>
    <title>Static File Serving Demo</title>
-    <meta charset="UTF-8">
  </head>
  <body>
    <h1>Static File Serving Demo</h1>
--- a/examples/streaming/video_stream.py
+++ b/examples/streaming/video_stream.py
@@ -1,5 +1,8 @@
-import sys
-import asyncio
+try:
+    import utime as time
+except ImportError:
+    import time
+
 from microdot import Microdot

 app = Microdot()
@@ -11,12 +14,11 @@ for file in ['1.jpg', '2.jpg', '3.jpg']:


@app.route('/')
-async def index(request):
+def index(request):
    return '''<!doctype html>
 <html>
  <head>
    <title>Microdot Video Streaming</title>
-    <meta charset="UTF-8">
  </head>
  <body>
    <h1>Microdot Video Streaming</h1>
@@ -26,38 +28,14 @@ async def index(request):


@app.route('/video_feed')
-async def video_feed(request):
-    print('Starting video stream.')
-
-    if sys.implementation.name != 'micropython':
-        # CPython supports async generator function
-        async def stream():
-            try:
-                yield b'--frame\r\n'
-                while True:
-                    for frame in frames:
-                        yield b'Content-Type: image/jpeg\r\n\r\n' + frame + \
-                            b'\r\n--frame\r\n'
-                        await asyncio.sleep(1)
-            except GeneratorExit:
-                print('Stopping video stream.')
-    else:
-        # MicroPython can only use class-based async generators
-        class stream():
-            def __init__(self):
-                self.i = 0
-
-            def __aiter__(self):
-                return self
-
-            async def __anext__(self):
-                await asyncio.sleep(1)
-                self.i = (self.i + 1) % len(frames)
-                return b'Content-Type: image/jpeg\r\n\r\n' + \
-                    frames[self.i] + b'\r\n--frame\r\n'
-
-            async def aclose(self):
-                print('Stopping video stream.')
+def video_feed(request):
+    def stream():
+        yield b'--frame\r\n'
+        while True:
+            for frame in frames:
+                yield b'Content-Type: image/jpeg\r\n\r\n' + frame + \
+                    b'\r\n--frame\r\n'
+                time.sleep(1)

    return stream(), 200, {'Content-Type':
                           'multipart/x-mixed-replace; boundary=frame'}
--- a/examples/streaming/video_stream_async.py
+++ b/examples/streaming/video_stream_async.py
@@ -0,0 +1,64 @@
+import sys
+
+try:
+    import uasyncio as asyncio
+except ImportError:
+    import asyncio
+
+from microdot_asyncio import Microdot
+
+app = Microdot()
+
+frames = []
+for file in ['1.jpg', '2.jpg', '3.jpg']:
+    with open(file, 'rb') as f:
+        frames.append(f.read())
+
+
+@app.route('/')
+def index(request):
+    return '''<!doctype html>
+<html>
+  <head>
+    <title>Microdot Video Streaming</title>
+  </head>
+  <body>
+    <h1>Microdot Video Streaming</h1>
+    <img src="/video_feed">
+  </body>
+</html>''', 200, {'Content-Type': 'text/html'}
+
+
+@app.route('/video_feed')
+async def video_feed(request):
+    if sys.implementation.name != 'micropython':
+        # CPython supports yielding async generators
+        async def stream():
+            yield b'--frame\r\n'
+            while True:
+                for frame in frames:
+                    yield b'Content-Type: image/jpeg\r\n\r\n' + frame + \
+                        b'\r\n--frame\r\n'
+                    await asyncio.sleep(1)
+
+    else:
+        # MicroPython can only use class-based async generators
+        class stream():
+            def __init__(self):
+                self.i = 0
+
+            def __aiter__(self):
+                return self
+
+            async def __anext__(self):
+                await asyncio.sleep(1)
+                self.i = (self.i + 1) % len(frames)
+                return b'Content-Type: image/jpeg\r\n\r\n' + \
+                    frames[self.i] + b'\r\n--frame\r\n'
+
+    return stream(), 200, {'Content-Type':
+                           'multipart/x-mixed-replace; boundary=frame'}
+
+
+if __name__ == '__main__':
+    app.run(debug=True)
--- a/examples/subapps/README.md
+++ b/examples/subapps/README.md
@@ -1 +0,0 @@
-This directory contains examples that demonstrate sub-applications.
--- a/examples/subapps/app.py
+++ b/examples/subapps/app.py
@@ -1,27 +0,0 @@
-from microdot import Microdot
-from subapp import subapp
-
-app = Microdot()
-app.mount(subapp, url_prefix='/subapp')
-
-
-@app.route('/')
-async def hello(request):
-    return '''
-        <!DOCTYPE html>
-        <html>
-            <head>
-                <title>Microdot Sub-App Example</title>
-                <meta charset="UTF-8">
-            </head>
-            <body>
-                <div>
-                    <h1>Microdot Main Page</h1>
-                    <p>Visit the <a href="/subapp">sub-app</a>.</p>
-                </div>
-            </body>
-        </html>
-    ''', 200, {'Content-Type': 'text/html'}
-
-
-app.run(debug=True)
--- a/examples/subapps/subapp.py
+++ b/examples/subapps/subapp.py
@@ -1,44 +0,0 @@
-from microdot import Microdot
-
-subapp = Microdot()
-
-
-@subapp.route('')
-async def hello(request):
-    # request.url_prefix can be used in links that are relative to this subapp
-    return f'''
-        <!DOCTYPE html>
-        <html>
-            <head>
-                <title>Microdot Sub-App Example</title>
-                <meta charset="UTF-8">
-            </head>
-            <body>
-                <div>
-                    <h1>Microdot Sub-App Main Page</h1>
-                    <p>Visit the sub-app's <a href="{request.url_prefix}/second">secondary page</a>.</p>
-                    <p>Go back to the app's <a href="/">main page</a>.</p>
-                </div>
-            </body>
-        </html>
-    ''', 200, {'Content-Type': 'text/html'}  # noqa: E501
-
-
-@subapp.route('/second')
-async def second(request):
-    return f'''
-        <!DOCTYPE html>
-        <html>
-            <head>
-                <title>Microdot Sub-App Example</title>
-                <meta charset="UTF-8">
-            </head>
-            <body>
-                <div>
-                    <h1>Microdot Sub-App Secondary Page</h1>
-                    <p>Visit the sub-app's <a href="{request.url_prefix}">main page</a>.</p>
-                    <p>Go back to the app's <a href="/">main page</a>.</p>
-                </div>
-            </body>
-        </html>
-    ''', 200, {'Content-Type': 'text/html'}  # noqa: E501
--- a/examples/templates/jinja/async_template.py
+++ b/examples/templates/jinja/async_template.py
@@ -1,18 +0,0 @@
-from microdot import Microdot, Response
-from microdot.jinja import Template
-
-Template.initialize('templates', enable_async=True)
-app = Microdot()
-Response.default_content_type = 'text/html'
-
-
-@app.route('/', methods=['GET', 'POST'])
-async def index(req):
-    name = None
-    if req.method == 'POST':
-        name = req.form.get('name')
-    return await Template('index.html').render_async(name=name)
-
-
-if __name__ == '__main__':
-    app.run()
--- a/examples/templates/jinja/bootstrap.py
+++ b/examples/templates/jinja/bootstrap.py
@@ -1,19 +0,0 @@
-from microdot import Microdot, Response
-from microdot.jinja import Template
-
-app = Microdot()
-Response.default_content_type = 'text/html'
-
-
-@app.route('/')
-async def index(req):
-    return Template('page1.html').render(page='Page 1')
-
-
-@app.route('/page2')
-async def page2(req):
-    return Template('page2.html').render(page='Page 2')
-
-
-if __name__ == '__main__':
-    app.run()
--- a/examples/templates/jinja/hello.py
+++ b/examples/templates/jinja/hello.py
@@ -1,17 +0,0 @@
-from microdot import Microdot, Response
-from microdot.jinja import Template
-
-app = Microdot()
-Response.default_content_type = 'text/html'
-
-
-@app.route('/', methods=['GET', 'POST'])
-async def index(req):
-    name = None
-    if req.method == 'POST':
-        name = req.form.get('name')
-    return Template('index.html').render(name=name)
-
-
-if __name__ == '__main__':
-    app.run()
--- a/examples/templates/jinja/hello_wsgi.py
+++ b/examples/templates/jinja/hello_wsgi.py
@@ -1,17 +0,0 @@
-from microdot.wsgi import Microdot, Response
-from microdot.jinja import Template
-
-app = Microdot()
-Response.default_content_type = 'text/html'
-
-
-@app.route('/', methods=['GET', 'POST'])
-async def index(req):
-    name = None
-    if req.method == 'POST':
-        name = req.form.get('name')
-    return Template('index.html').render(name=name)
-
-
-if __name__ == '__main__':
-    app.run()
--- a/examples/templates/jinja/templates/base.html
+++ b/examples/templates/jinja/templates/base.html
@@ -1,48 +0,0 @@
-<!--
-  This is based on the Bootstrap 5 starter template from the documentation:
-  https://getbootstrap.com/docs/5.0/getting-started/introduction/#starter-template
-->
-<!doctype html>
-<html lang="en">
-  <head>
-    <!-- Required meta tags -->
-    <meta charset="utf-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1">
-
-    <!-- Bootstrap CSS -->
-    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-EVSTQN3/azprG1Anm3QDgpJLIm9Nao0Yz1ztcQTwFspd3yD65VohhpuuCOmLASjC" crossorigin="anonymous">
-
-    <title>Microdot + Jinja + Bootstrap</title>
-  </head>
-  <body>
-    <nav class="navbar navbar-expand-lg navbar-light bg-light">
-      <div class="container">
-        <a class="navbar-brand" href="/">Microdot + Jinja + Bootstrap</a>
-      </div>
-    </nav>
-    <br>
-    <div class="container">
-      <svg xmlns="http://www.w3.org/2000/svg" style="display: none;">
-        <symbol id="info-fill" fill="currentColor" viewBox="0 0 16 16">
-          <path d="M8 16A8 8 0 1 0 8 0a8 8 0 0 0 0 16zm.93-9.412-1 4.705c-.07.34.029.533.304.533.194 0 .487-.07.686-.246l-.088.416c-.287.346-.92.598-1.465.598-.703 0-1.002-.422-.808-1.319l.738-3.468c.064-.293.006-.399-.287-.47l-.451-.081.082-.381 2.29-.287zM8 5.5a1 1 0 1 1 0-2 1 1 0 0 1 0 2z"/>
-        </symbol>
-      </svg>
-      <div class="alert alert-primary d-flex align-items-center" role="alert">
-        <svg class="bi flex-shrink-0 me-2" width="24" height="24" role="img" aria-label="Info:"><use xlink:href="#info-fill"/></svg>
-        <div>This example demonstrates how to create an application that uses <a href="https://getbootstrap.com" class="alert-link">Bootstrap</a> styling. The page layout is defined in a base template that is inherited by several pages.</div>
-      </div>
-      {% block content %}{% endblock %}
-    </div>
-
-    <!-- Optional JavaScript; choose one of the two! -->
-
-    <!-- Option 1: Bootstrap Bundle with Popper -->
-    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/js/bootstrap.bundle.min.js" integrity="sha384-MrcW6ZMFYlzcLA8Nl+NtUVF0sA7MsXsP1UyJoMp4YLEuNSfAP+JcXn/tWtIaxVXM" crossorigin="anonymous"></script>
-
-    <!-- Option 2: Separate Popper and Bootstrap JS -->
-    <!--
-    <script src="https://cdn.jsdelivr.net/npm/@popperjs/core@2.9.2/dist/umd/popper.min.js" integrity="sha384-IQsoLXl5PILFhosVNubq5LC7Qb9DXgDA9i+tQ8Zj3iwWAwPtgFTxbJ8NT4GN1R8p" crossorigin="anonymous"></script>
-    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/js/bootstrap.min.js" integrity="sha384-cVKIPhGWiC2Al4u+LWgxfKTRIcfu0JTxR+EQDz/bgldoEyl4H0zUF0QKbrJ0EcQF" crossorigin="anonymous"></script>
-    -->
-  </body>
-</html>
--- a/examples/templates/jinja/templates/page1.html
+++ b/examples/templates/jinja/templates/page1.html
@@ -1,6 +0,0 @@
-{% extends 'base.html' %}
-
-{% block content %}
-<h2>This is {{ page }}</h2>
-<p>Go to <a href="/page2">Page 2</a>.</p>
-{% endblock %}
--- a/examples/templates/jinja/templates/page2.html
+++ b/examples/templates/jinja/templates/page2.html
@@ -1,6 +0,0 @@
-{% extends 'base.html' %}
-
-{% block content %}
-<h2>This is {{ page }}</h2>
-<p>Go back <a href="/">Page 1</a>.</p>
-{% endblock %}
--- a/examples/templates/utemplate/async_template.py
+++ b/examples/templates/utemplate/async_template.py
@@ -1,17 +0,0 @@
-from microdot import Microdot, Response
-from microdot.utemplate import Template
-
-app = Microdot()
-Response.default_content_type = 'text/html'
-
-
-@app.route('/', methods=['GET', 'POST'])
-async def index(req):
-    name = None
-    if req.method == 'POST':
-        name = req.form.get('name')
-    return await Template('index.html').render_async(name=name)
-
-
-if __name__ == '__main__':
-    app.run()
--- a/examples/templates/utemplate/bootstrap.py
+++ b/examples/templates/utemplate/bootstrap.py
@@ -1,19 +0,0 @@
-from microdot import Microdot, Response
-from microdot.utemplate import Template
-
-app = Microdot()
-Response.default_content_type = 'text/html'
-
-
-@app.route('/')
-async def index(req):
-    return Template('page1.html').render(page='Page 1')
-
-
-@app.route('/page2')
-async def page2(req):
-    return Template('page2.html').render(page='Page 2')
-
-
-if __name__ == '__main__':
-    app.run(debug=True)
--- a/examples/templates/utemplate/hello.py
+++ b/examples/templates/utemplate/hello.py
@@ -1,17 +0,0 @@
-from microdot import Microdot, Response
-from microdot.utemplate import Template
-
-app = Microdot()
-Response.default_content_type = 'text/html'
-
-
-@app.route('/', methods=['GET', 'POST'])
-async def index(req):
-    name = None
-    if req.method == 'POST':
-        name = req.form.get('name')
-    return Template('index.html').render(name=name)
-
-
-if __name__ == '__main__':
-    app.run()
--- a/examples/templates/utemplate/hello_asgi.py
+++ b/examples/templates/utemplate/hello_asgi.py
@@ -1,17 +0,0 @@
-from microdot.asgi import Microdot, Response
-from microdot.utemplate import Template
-
-app = Microdot()
-Response.default_content_type = 'text/html'
-
-
-@app.route('/', methods=['GET', 'POST'])
-async def index(req):
-    name = None
-    if req.method == 'POST':
-        name = req.form.get('name')
-    return Template('index.html').render(name=name)
-
-
-if __name__ == '__main__':
-    app.run()
--- a/examples/templates/utemplate/hello_wsgi.py
+++ b/examples/templates/utemplate/hello_wsgi.py
@@ -1,17 +0,0 @@
-from microdot.wsgi import Microdot, Response
-from microdot.utemplate import Template
-
-app = Microdot()
-Response.default_content_type = 'text/html'
-
-
-@app.route('/', methods=['GET', 'POST'])
-async def index(req):
-    name = None
-    if req.method == 'POST':
-        name = req.form.get('name')
-    return Template('index.html').render(name=name)
-
-
-if __name__ == '__main__':
-    app.run()
--- a/examples/templates/utemplate/templates/base_footer.html
+++ b/examples/templates/utemplate/templates/base_footer.html
@@ -1,14 +0,0 @@
-    </div>
-
-    <!-- Optional JavaScript; choose one of the two! -->
-
-    <!-- Option 1: Bootstrap Bundle with Popper -->
-    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/js/bootstrap.bundle.min.js" integrity="sha384-MrcW6ZMFYlzcLA8Nl+NtUVF0sA7MsXsP1UyJoMp4YLEuNSfAP+JcXn/tWtIaxVXM" crossorigin="anonymous"></script>
-
-    <!-- Option 2: Separate Popper and Bootstrap JS -->
-    <!--
-    <script src="https://cdn.jsdelivr.net/npm/@popperjs/core@2.9.2/dist/umd/popper.min.js" integrity="sha384-IQsoLXl5PILFhosVNubq5LC7Qb9DXgDA9i+tQ8Zj3iwWAwPtgFTxbJ8NT4GN1R8p" crossorigin="anonymous"></script>
-    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/js/bootstrap.min.js" integrity="sha384-cVKIPhGWiC2Al4u+LWgxfKTRIcfu0JTxR+EQDz/bgldoEyl4H0zUF0QKbrJ0EcQF" crossorigin="anonymous"></script>
-    -->
-  </body>
-</html>
--- a/examples/templates/utemplate/templates/base_header.html
+++ b/examples/templates/utemplate/templates/base_header.html
@@ -1,33 +0,0 @@
-<!--
-  This is based on the Bootstrap 5 starter template from the documentation:
-  https://getbootstrap.com/docs/5.0/getting-started/introduction/#starter-template
-->
-<!doctype html>
-<html lang="en">
-  <head>
-    <!-- Required meta tags -->
-    <meta charset="utf-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1">
-
-    <!-- Bootstrap CSS -->
-    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-EVSTQN3/azprG1Anm3QDgpJLIm9Nao0Yz1ztcQTwFspd3yD65VohhpuuCOmLASjC" crossorigin="anonymous">
-
-    <title>Microdot + uTemplate + Bootstrap</title>
-  </head>
-  <body>
-    <nav class="navbar navbar-expand-lg navbar-light bg-light">
-      <div class="container">
-        <a class="navbar-brand" href="/">Microdot + uTemplate + Bootstrap</a>
-      </div>
-    </nav>
-    <br>
-    <div class="container">
-      <svg xmlns="http://www.w3.org/2000/svg" style="display: none;">
-        <symbol id="info-fill" fill="currentColor" viewBox="0 0 16 16">
-          <path d="M8 16A8 8 0 1 0 8 0a8 8 0 0 0 0 16zm.93-9.412-1 4.705c-.07.34.029.533.304.533.194 0 .487-.07.686-.246l-.088.416c-.287.346-.92.598-1.465.598-.703 0-1.002-.422-.808-1.319l.738-3.468c.064-.293.006-.399-.287-.47l-.451-.081.082-.381 2.29-.287zM8 5.5a1 1 0 1 1 0-2 1 1 0 0 1 0 2z"/>
-        </symbol>
-      </svg>
-      <div class="alert alert-primary d-flex align-items-center" role="alert">
-        <svg class="bi flex-shrink-0 me-2" width="24" height="24" role="img" aria-label="Info:"><use xlink:href="#info-fill"/></svg>
-        <div>This example demonstrates how to create an application that uses <a href="https://getbootstrap.com" class="alert-link">Bootstrap</a> styling. The page layout is defined in a base template that is inherited by several pages.</div>
-      </div>
--- a/examples/templates/utemplate/templates/page1.html
+++ b/examples/templates/utemplate/templates/page1.html
@@ -1,7 +0,0 @@
-{% args page %}
-{% include 'base_header.html' %}
-
-<h2>This is {{ page }}</h2>
-<p>Go to <a href="/page2">Page 2</a>.</p>
-
-{% include 'base_footer.html' %}
--- a/examples/templates/utemplate/templates/page2.html
+++ b/examples/templates/utemplate/templates/page2.html
@@ -1,7 +0,0 @@
-{% args page %}
-{% include 'base_header.html' %}
-
-<h2>This is {{ page }}</h2>
-<p>Go back <a href="/">Page 1</a>.</p>
-
-{% include 'base_footer.html' %}
--- a/examples/tls/echo_async_tls.py
+++ b/examples/tls/echo_async_tls.py
@@ -0,0 +1,23 @@
+import ssl
+from microdot_asyncio import Microdot, send_file
+from microdot_asyncio_websocket import with_websocket
+
+app = Microdot()
+
+
+@app.route('/')
+def index(request):
+    return send_file('index.html')
+
+
+@app.route('/echo')
+@with_websocket
+async def echo(request, ws):
+    while True:
+        data = await ws.receive()
+        await ws.send(data)
+
+
+sslctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+sslctx.load_cert_chain('cert.pem', 'key.pem')
+app.run(port=4443, debug=True, ssl=sslctx)
--- a/examples/tls/echo_tls.py
+++ b/examples/tls/echo_tls.py
@@ -0,0 +1,24 @@
+import sys
+from microdot import Microdot, send_file
+from microdot_websocket import with_websocket
+from microdot_ssl import create_ssl_context
+
+app = Microdot()
+
+
+@app.route('/')
+def index(request):
+    return send_file('index.html')
+
+
+@app.route('/echo')
+@with_websocket
+def echo(request, ws):
+    while True:
+        data = ws.receive()
+        ws.send(data)
+
+
+ext = 'der' if sys.implementation.name == 'micropython' else 'pem'
+sslctx = create_ssl_context('cert.' + ext, 'key.' + ext)
+app.run(port=4443, debug=True, ssl=sslctx)
--- a/examples/tls/hello_async_tls.py
+++ b/examples/tls/hello_async_tls.py
@@ -1,14 +1,12 @@
 import ssl
-import sys
-from microdot import Microdot
+from microdot_asyncio import Microdot

 app = Microdot()

-html = '''<!DOCTYPE html>
+htmldoc = '''<!DOCTYPE html>
 <html>
    <head>
        <title>Microdot Example Page</title>
-        <meta charset="UTF-8">
    </head>
    <body>
        <div>
@@ -23,7 +21,7 @@ html = '''<!DOCTYPE html>

@app.route('/')
 async def hello(request):
-    return html, 200, {'Content-Type': 'text/html'}
+    return htmldoc, 200, {'Content-Type': 'text/html'}


@app.route('/shutdown')
@@ -32,7 +30,6 @@ async def shutdown(request):
    return 'The server is shutting down...'


-ext = 'der' if sys.implementation.name == 'micropython' else 'pem'
 sslctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
-sslctx.load_cert_chain('cert.' + ext, 'key.' + ext)
+sslctx.load_cert_chain('cert.pem', 'key.pem')
 app.run(port=4443, debug=True, ssl=sslctx)
--- a/examples/tls/hello_tls.py
+++ b/examples/tls/hello_tls.py
@@ -0,0 +1,36 @@
+import sys
+from microdot import Microdot
+from microdot_ssl import create_ssl_context
+
+app = Microdot()
+
+htmldoc = '''<!DOCTYPE html>
+<html>
+    <head>
+        <title>Microdot Example Page</title>
+    </head>
+    <body>
+        <div>
+            <h1>Microdot Example Page</h1>
+            <p>Hello from Microdot!</p>
+            <p><a href="/shutdown">Click to shutdown the server</a></p>
+        </div>
+    </body>
+</html>
+'''
+
+
+@app.route('/')
+def hello(request):
+    return htmldoc, 200, {'Content-Type': 'text/html'}
+
+
+@app.route('/shutdown')
+def shutdown(request):
+    request.app.shutdown()
+    return 'The server is shutting down...'
+
+
+ext = 'der' if sys.implementation.name == 'micropython' else 'pem'
+sslctx = create_ssl_context('cert.' + ext, 'key.' + ext)
+app.run(port=4443, debug=True, ssl=sslctx)
--- a/examples/tls/index.html
+++ b/examples/tls/index.html
@@ -0,0 +1,35 @@
+<!doctype html>
+<html>
+  <head>
+    <title>Microdot TLS WebSocket Demo</title>
+  </head>
+  <body>
+    <h1>Microdot TLS WebSocket Demo</h1>
+    <div id="log"></div>
+    <br>
+    <form id="form">
+      <label for="text">Input: </label>
+      <input type="text" id="text" autofocus>
+    </form>
+    <script>
+      const log = (text, color) => {
+        document.getElementById('log').innerHTML += `<span style="color: ${color}">${text}</span><br>`;
+      };
+
+      const socket = new WebSocket('wss://' + location.host + '/echo');
+      socket.addEventListener('message', ev => {
+        log('<<< ' + ev.data, 'blue');
+      });
+      socket.addEventListener('close', ev => {
+        log('<<< closed');
+      });
+      document.getElementById('form').onsubmit = ev => {
+        ev.preventDefault();
+        const textField = document.getElementById('text');
+        log('>>> ' + textField.value, 'red');
+        socket.send(textField.value);
+        textField.value = '';
+      };
+    </script>
+  </body>
+</html>
--- a/examples/uploads/README.md
+++ b/examples/uploads/README.md
@@ -1,4 +1 @@
 This directory contains file upload examples.
-
- `simple_uploads.py` demonstrates how to upload a single file.
- `formdata.py` demonstrates how to process a form that includes file uploads.
--- a/examples/uploads/formdata.html
+++ b/examples/uploads/formdata.html
@@ -1,17 +0,0 @@
-<!doctype html>
-<html>
-  <head>
-    <title>Microdot Multipart Form-Data Example</title>
-    <meta charset="UTF-8">
-  </head>
-  <body>
-    <h1>Microdot Multipart Form-Data Example</h1>
-    <form method="POST" action="" enctype="multipart/form-data">
-      <p>Name: <input type="text" name="name" /></p>
-      <p>Age: <input type="text" name="age" /></p>
-      <p>Comments: <textarea name="comments" rows="4"></textarea></p>
-      <p>File: <input type="file" id="file" name="file" /></p>
-      <input type="submit" value="Submit" />
-    </form>
-  </body>
-</html>
--- a/examples/uploads/formdata.py
+++ b/examples/uploads/formdata.py
@@ -1,26 +0,0 @@
-from microdot import Microdot, send_file, Request
-from microdot.multipart import with_form_data
-
-app = Microdot()
-Request.max_content_length = 1024 * 1024  # 1MB (change as needed)
-
-
-@app.get('/')
-async def index(request):
-    return send_file('formdata.html')
-
-
-@app.post('/')
-@with_form_data
-async def upload(request):
-    print('Form fields:')
-    for field, value in request.form.items():
-        print(f'- {field}: {value}')
-    print('\nFile uploads:')
-    for field, value in request.files.items():
-        print(f'- {field}: {value.filename}, {await value.read()}')
-    return 'We have received your data!'
-
-
-if __name__ == '__main__':
-    app.run(debug=True)
--- a/examples/uploads/simple_uploads.html
+++ b/examples/uploads/simple_uploads.html
@@ -2,7 +2,6 @@
 <html>
  <head>
    <title>Microdot Upload Example</title>
-    <meta charset="UTF-8">
  </head>
  <body>
    <h1>Microdot Upload Example</h1>
--- a/examples/uploads/simple_uploads.py
+++ b/examples/uploads/simple_uploads.py
@@ -1,16 +1,15 @@
-from microdot import Microdot, send_file, Request
+from microdot import Microdot, send_file

 app = Microdot()
-Request.max_content_length = 1024 * 1024  # 1MB (change as needed)


@app.get('/')
-async def index(request):
-    return send_file('simple_uploads.html')
+def index(request):
+    return send_file('index.html')


@app.post('/upload')
-async def upload(request):
+def upload(request):
    # obtain the filename and size from request headers
    filename = request.headers['Content-Disposition'].split(
        'filename=')[1].strip('"')
@@ -22,7 +21,7 @@ async def upload(request):
    # write the file to the files directory in 1K chunks
    with open('files/' + filename, 'wb') as f:
        while size > 0:
-            chunk = await request.stream.read(min(size, 1024))
+            chunk = request.stream.read(min(size, 1024))
            f.write(chunk)
            size -= len(chunk)

@@ -31,4 +30,4 @@ async def upload(request):


 if __name__ == '__main__':
-    app.run(debug=True)
+    app.run()
--- a/examples/websocket/echo.py
+++ b/examples/websocket/echo.py
@@ -1,20 +1,20 @@
 from microdot import Microdot, send_file
-from microdot.websocket import with_websocket
+from microdot_websocket import with_websocket

 app = Microdot()


@app.route('/')
-async def index(request):
+def index(request):
    return send_file('index.html')


@app.route('/echo')
@with_websocket
-async def echo(request, ws):
+def echo(request, ws):
    while True:
-        data = await ws.receive()
-        await ws.send(data)
+        data = ws.receive()
+        ws.send(data)


 app.run()
--- a/examples/websocket/echo_asgi.py
+++ b/examples/websocket/echo_asgi.py
@@ -1,10 +1,11 @@
-from microdot.asgi import Microdot, send_file, with_websocket
+from microdot_asgi import Microdot, send_file
+from microdot_asgi_websocket import with_websocket

 app = Microdot()


@app.route('/')
-async def index(request):
+def index(request):
    return send_file('index.html')


@@ -14,7 +15,3 @@ async def echo(request, ws):
    while True:
        data = await ws.receive()
        await ws.send(data)
-
-
-if __name__ == '__main__':
-    app.run()
--- a/examples/websocket/echo_async.py
+++ b/examples/websocket/echo_async.py
@@ -0,0 +1,20 @@
+from microdot_asyncio import Microdot, send_file
+from microdot_asyncio_websocket import with_websocket
+
+app = Microdot()
+
+
+@app.route('/')
+def index(request):
+    return send_file('index.html')
+
+
+@app.route('/echo')
+@with_websocket
+async def echo(request, ws):
+    while True:
+        data = await ws.receive()
+        await ws.send(data)
+
+
+app.run()
--- a/examples/websocket/echo_wsgi.py
+++ b/examples/websocket/echo_wsgi.py
@@ -1,20 +1,17 @@
-from microdot.wsgi import Microdot, send_file, with_websocket
+from microdot_wsgi import Microdot, send_file
+from microdot_websocket import with_websocket

 app = Microdot()


@app.route('/')
-async def index(request):
+def index(request):
    return send_file('index.html')


@app.route('/echo')
@with_websocket
-async def echo(request, ws):
+def echo(request, ws):
    while True:
-        data = await ws.receive()
-        await ws.send(data)
-
-
-if __name__ == '__main__':
-    app.run()
+        data = ws.receive()
+        ws.send(data)
--- a/examples/websocket/index.html
+++ b/examples/websocket/index.html
@@ -2,7 +2,6 @@
 <html>
  <head>
    <title>Microdot WebSocket Demo</title>
-    <meta charset="UTF-8">
  </head>
  <body>
    <h1>Microdot WebSocket Demo</h1>
--- a/libs/circuitpython/adafruit_ticks.py
+++ b/libs/circuitpython/adafruit_ticks.py
@@ -1,139 +0,0 @@
-# SPDX-FileCopyrightText: 2017 Scott Shawcroft, written for Adafruit Industries
-# SPDX-FileCopyrightText: Copyright (c) 2021 Jeff Epler for Adafruit Industries
-#
-# SPDX-License-Identifier: MIT
-"""
-`adafruit_ticks`
-================================================================================
-
-Work with intervals and deadlines in milliseconds
-
-
-* Author(s): Jeff Epler
-
-Implementation Notes
--------------------
-
-**Software and Dependencies:**
-
-* Adafruit CircuitPython firmware for the supported boards:
-  https://github.com/adafruit/circuitpython/releases
-
-"""
-
-# imports
-from micropython import const
-
-__version__ = "0.0.0+auto.0"
-__repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_ticks.git"
-
-_TICKS_PERIOD = const(1 << 29)
-_TICKS_MAX = const(_TICKS_PERIOD - 1)
-_TICKS_HALFPERIOD = const(_TICKS_PERIOD // 2)
-
-# Get the correct implementation of ticks_ms.  There are three possibilities:
-#
-#  - supervisor.ticks_ms is present.  This will be the case starting in CP7.0
-#
-#  - time.ticks_ms is present. This is the case for MicroPython & for the "unix
-#    port" of CircuitPython, used for some automated testing.
-#
-#  - time.monotonic_ns is present, and works.  This is the case on most
-#    Express boards in CP6.x, and most host computer versions of Python.
-#
-#  - Otherwise, time.monotonic is assumed to be present.  This is the case
-#    on most non-express boards in CP6.x, and some old host computer versions
-#    of Python.
-#
-#    Note that on microcontrollers, this time source becomes increasingly
-#    inaccurate when the board has not been reset in a long time, losing the
-#    ability to measure 1ms intervals after about 1 hour, and losing the
-#    ability to meausre 128ms intervals after 6 days.  The only solution is to
-#    either upgrade to a version with supervisor.ticks_ms, or to switch to a
-#    board with time.monotonic_ns.
-
-try:
-    from supervisor import ticks_ms  # pylint: disable=unused-import
-except (ImportError, NameError):
-    import time
-
-    if _ticks_ms := getattr(time, "ticks_ms", None):
-
-        def ticks_ms() -> int:
-            """Return the time in milliseconds since an unspecified moment,
-            wrapping after 2**29ms.
-
-            The wrap value was chosen so that it is always possible to add or
-            subtract two `ticks_ms` values without overflow on a board without
-            long ints (or without allocating any long integer objects, on
-            boards with long ints).
-
-            This ticks value comes from a low-accuracy clock internal to the
-            microcontroller, just like `time.monotonic`.  Due to its low
-            accuracy and the fact that it "wraps around" every few days, it is
-            intended for working with short term events like advancing an LED
-            animation, not for long term events like counting down the time
-            until a holiday."""
-            return _ticks_ms() & _TICKS_MAX  # pylint: disable=not-callable
-
-    else:
-        try:
-            from time import monotonic_ns as _monotonic_ns
-
-            _monotonic_ns()  # Check that monotonic_ns is usable
-
-            def ticks_ms() -> int:
-                """Return the time in milliseconds since an unspecified moment,
-                wrapping after 2**29ms.
-
-                The wrap value was chosen so that it is always possible to add or
-                subtract two `ticks_ms` values without overflow on a board without
-                long ints (or without allocating any long integer objects, on
-                boards with long ints).
-
-                This ticks value comes from a low-accuracy clock internal to the
-                microcontroller, just like `time.monotonic`.  Due to its low
-                accuracy and the fact that it "wraps around" every few days, it is
-                intended for working with short term events like advancing an LED
-                animation, not for long term events like counting down the time
-                until a holiday."""
-                return (_monotonic_ns() // 1_000_000) & _TICKS_MAX
-
-        except (ImportError, NameError, NotImplementedError):
-            from time import monotonic as _monotonic
-
-            def ticks_ms() -> int:
-                """Return the time in milliseconds since an unspecified moment,
-                wrapping after 2**29ms.
-
-                The wrap value was chosen so that it is always possible to add or
-                subtract two `ticks_ms` values without overflow on a board without
-                long ints (or without allocating any long integer objects, on
-                boards with long ints).
-
-                This ticks value comes from a low-accuracy clock internal to the
-                microcontroller, just like `time.monotonic`.  Due to its low
-                accuracy and the fact that it "wraps around" every few days, it is
-                intended for working with short term events like advancing an LED
-                animation, not for long term events like counting down the time
-                until a holiday."""
-                return int(_monotonic() * 1000) & _TICKS_MAX
-
-
-def ticks_add(ticks: int, delta: int) -> int:
-    "Add a delta to a base number of ticks, performing wraparound at 2**29ms."
-    return (ticks + delta) % _TICKS_PERIOD
-
-
-def ticks_diff(ticks1: int, ticks2: int) -> int:
-    """Compute the signed difference between two ticks values,
-    assuming that they are within 2**28 ticks"""
-    diff = (ticks1 - ticks2) & _TICKS_MAX
-    diff = ((diff + _TICKS_HALFPERIOD) & _TICKS_MAX) - _TICKS_HALFPERIOD
-    return diff
-
-
-def ticks_less(ticks1: int, ticks2: int) -> bool:
-    """Return true if ticks1 is before ticks2 and false otherwise,
-    assuming that they are within 2**28 ticks"""
-    return ticks_diff(ticks1, ticks2) < 0
--- a/libs/circuitpython/asyncio/init.py
+++ b/libs/circuitpython/asyncio/init.py
@@ -1,41 +0,0 @@
-# SPDX-FileCopyrightText: 2019 Damien P. George
-#
-# SPDX-License-Identifier: MIT
-#
-# MicroPython uasyncio module
-# MIT license; Copyright (c) 2019 Damien P. George
-#
-# This code comes from MicroPython, and has not been run through black or pylint there.
-# Altering these files significantly would make merging difficult, so we will not use
-# pylint or black.
-# pylint: skip-file
-# fmt: off
-
-from .core import *
-
-__version__ = "0.0.0+auto.0"
-__repo__ = "https://github.com/Adafruit/Adafruit_CircuitPython_asyncio.git"
-
-_attrs = {
-    "wait_for": "funcs",
-    "wait_for_ms": "funcs",
-    "gather": "funcs",
-    "Event": "event",
-    "ThreadSafeFlag": "event",
-    "Lock": "lock",
-    "open_connection": "stream",
-    "start_server": "stream",
-    "StreamReader": "stream",
-    "StreamWriter": "stream",
-}
-
-# Lazy loader, effectively does:
-#   global attr
-#   from .mod import attr
-def __getattr__(attr):
-    mod = _attrs.get(attr, None)
-    if mod is None:
-        raise AttributeError(attr)
-    value = getattr(__import__(mod, None, None, True, 1), attr)
-    globals()[attr] = value
-    return value
--- a/libs/circuitpython/asyncio/core.py
+++ b/libs/circuitpython/asyncio/core.py
@@ -1,430 +0,0 @@
-# SPDX-FileCopyrightText: 2019 Damien P. George
-#
-# SPDX-License-Identifier: MIT
-#
-# MicroPython uasyncio module
-# MIT license; Copyright (c) 2019 Damien P. George
-#
-# This code comes from MicroPython, and has not been run through black or pylint there.
-# Altering these files significantly would make merging difficult, so we will not use
-# pylint or black.
-# pylint: skip-file
-# fmt: off
-"""
-Core
-====
-"""
-
-from adafruit_ticks import ticks_ms as ticks, ticks_diff, ticks_add
-import sys, select
-
-try:
-    from traceback import print_exception
-except:
-    from .traceback import print_exception
-
-# Import TaskQueue and Task, preferring built-in C code over Python code
-try:
-    from _asyncio import TaskQueue, Task
-except ImportError:
-    from .task import TaskQueue, Task
-
-################################################################################
-# Exceptions
-
-
-# Depending on the release of CircuitPython these errors may or may not
-# exist in the C implementation of `_asyncio`.  However, when they
-# do exist, they must be preferred over the Python code.
-try:
-    from _asyncio import CancelledError, InvalidStateError
-except (ImportError, AttributeError):
-    class CancelledError(BaseException):
-        """Injected into a task when calling `Task.cancel()`"""
-        pass
-
-
-    class InvalidStateError(Exception):
-        """Can be raised in situations like setting a result value for a task object that already has a result value set."""
-        pass
-
-
-class TimeoutError(Exception):
-    """Raised when waiting for a task longer than the specified timeout."""
-
-    pass
-
-
-# Used when calling Loop.call_exception_handler
-_exc_context = {"message": "Task exception wasn't retrieved", "exception": None, "future": None}
-
-
-################################################################################
-# Sleep functions
-
-# "Yield" once, then raise StopIteration
-class SingletonGenerator:
-    def __init__(self):
-        self.state = None
-        self.exc = StopIteration()
-
-    def __iter__(self):
-        return self
-
-    def __await__(self):
-        return self
-
-    def __next__(self):
-        if self.state is not None:
-            _task_queue.push_sorted(cur_task, self.state)
-            self.state = None
-            return None
-        else:
-            self.exc.__traceback__ = None
-            raise self.exc
-
-
-# Pause task execution for the given time (integer in milliseconds, uPy extension)
-# Use a SingletonGenerator to do it without allocating on the heap
-def sleep_ms(t, sgen=SingletonGenerator()):
-    """Sleep for *t* milliseconds.
-
-    This is a coroutine, and a MicroPython extension.
-    """
-
-    assert sgen.state is None, "Check for a missing `await` in your code"
-    sgen.state = ticks_add(ticks(), max(0, t))
-    return sgen
-
-
-# Pause task execution for the given time (in seconds)
-def sleep(t):
-    """Sleep for *t* seconds
-
-    This is a coroutine.
-    """
-
-    return sleep_ms(int(t * 1000))
-
-
-################################################################################
-# "Never schedule" object"
-# Don't re-schedule the object that awaits _never().
-# For internal use only. Some constructs, like `await event.wait()`,
-# work by NOT re-scheduling the task which calls wait(), but by
-# having some other task schedule it later.
-class _NeverSingletonGenerator:
-    def __init__(self):
-        self.state = None
-        self.exc = StopIteration()
-
-    def __iter__(self):
-        return self
-
-    def __await__(self):
-        return self
-
-    def __next__(self):
-        if self.state is not None:
-            self.state = None
-            return None
-        else:
-           self.exc.__traceback__ = None
-           raise self.exc
-
-def _never(sgen=_NeverSingletonGenerator()):
-    # assert sgen.state is None, "Check for a missing `await` in your code"
-    sgen.state = False
-    return sgen
-
-
-################################################################################
-# Queue and poller for stream IO
-
-
-class IOQueue:
-    def __init__(self):
-        self.poller = select.poll()
-        self.map = {}  # maps id(stream) to [task_waiting_read, task_waiting_write, stream]
-
-    def _enqueue(self, s, idx):
-        if id(s) not in self.map:
-            entry = [None, None, s]
-            entry[idx] = cur_task
-            self.map[id(s)] = entry
-            self.poller.register(s, select.POLLIN if idx == 0 else select.POLLOUT)
-        else:
-            sm = self.map[id(s)]
-            assert sm[idx] is None
-            assert sm[1 - idx] is not None
-            sm[idx] = cur_task
-            self.poller.modify(s, select.POLLIN | select.POLLOUT)
-        # Link task to this IOQueue so it can be removed if needed
-        cur_task.data = self
-
-    def _dequeue(self, s):
-        del self.map[id(s)]
-        self.poller.unregister(s)
-
-    async def queue_read(self, s):
-        self._enqueue(s, 0)
-        await _never()
-
-    async def queue_write(self, s):
-        self._enqueue(s, 1)
-        await _never()
-
-    def remove(self, task):
-        while True:
-            del_s = None
-            for k in self.map:  # Iterate without allocating on the heap
-                q0, q1, s = self.map[k]
-                if q0 is task or q1 is task:
-                    del_s = s
-                    break
-            if del_s is not None:
-                self._dequeue(s)
-            else:
-                break
-
-    def wait_io_event(self, dt):
-        for s, ev in self.poller.ipoll(dt):
-            sm = self.map[id(s)]
-            # print('poll', s, sm, ev)
-            if ev & ~select.POLLOUT and sm[0] is not None:
-                # POLLIN or error
-                _task_queue.push_head(sm[0])
-                sm[0] = None
-            if ev & ~select.POLLIN and sm[1] is not None:
-                # POLLOUT or error
-                _task_queue.push_head(sm[1])
-                sm[1] = None
-            if sm[0] is None and sm[1] is None:
-                self._dequeue(s)
-            elif sm[0] is None:
-                self.poller.modify(s, select.POLLOUT)
-            else:
-                self.poller.modify(s, select.POLLIN)
-
-
-################################################################################
-# Main run loop
-
-# Ensure the awaitable is a task
-def _promote_to_task(aw):
-    return aw if isinstance(aw, Task) else create_task(aw)
-
-
-# Create and schedule a new task from a coroutine
-def create_task(coro):
-    """Create a new task from the given coroutine and schedule it to run.
-
-    Returns the corresponding `Task` object.
-    """
-
-    if not hasattr(coro, "send"):
-        raise TypeError("coroutine expected")
-    t = Task(coro, globals())
-    _task_queue.push_head(t)
-    return t
-
-
-# Keep scheduling tasks until there are none left to schedule
-def run_until_complete(main_task=None):
-    """Run the given *main_task* until it completes."""
-
-    global cur_task
-    excs_all = (CancelledError, Exception)  # To prevent heap allocation in loop
-    excs_stop = (CancelledError, StopIteration)  # To prevent heap allocation in loop
-    while True:
-        # Wait until the head of _task_queue is ready to run
-        dt = 1
-        while dt > 0:
-            dt = -1
-            t = _task_queue.peek()
-            if t:
-                # A task waiting on _task_queue; "ph_key" is time to schedule task at
-                dt = max(0, ticks_diff(t.ph_key, ticks()))
-            elif not _io_queue.map:
-                # No tasks can be woken so finished running
-                return
-            # print('(poll {})'.format(dt), len(_io_queue.map))
-            _io_queue.wait_io_event(dt)
-
-        # Get next task to run and continue it
-        t = _task_queue.pop_head()
-        cur_task = t
-        try:
-            # Continue running the coroutine, it's responsible for rescheduling itself
-            exc = t.data
-            if not exc:
-                t.coro.send(None)
-            else:
-                # If the task is finished and on the run queue and gets here, then it
-                # had an exception and was not await'ed on.  Throwing into it now will
-                # raise StopIteration and the code below will catch this and run the
-                # call_exception_handler function.
-                t.data = None
-                t.coro.throw(exc)
-        except excs_all as er:
-            # Check the task is not on any event queue
-            assert t.data is None
-            # This task is done, check if it's the main task and then loop should stop
-            if t is main_task:
-                if isinstance(er, StopIteration):
-                    return er.value
-                raise er
-            if t.state:
-                # Task was running but is now finished.
-                waiting = False
-                if t.state is True:
-                    # "None" indicates that the task is complete and not await'ed on (yet).
-                    t.state = None
-                elif callable(t.state):
-                    # The task has a callback registered to be called on completion.
-                    t.state(t, er)
-                    t.state = False
-                    waiting = True
-                else:
-                    # Schedule any other tasks waiting on the completion of this task.
-                    while t.state.peek():
-                        _task_queue.push_head(t.state.pop_head())
-                        waiting = True
-                    # "False" indicates that the task is complete and has been await'ed on.
-                    t.state = False
-                if not waiting and not isinstance(er, excs_stop):
-                    # An exception ended this detached task, so queue it for later
-                    # execution to handle the uncaught exception if no other task retrieves
-                    # the exception in the meantime (this is handled by Task.throw).
-                    _task_queue.push_head(t)
-                # Save return value of coro to pass up to caller.
-                t.data = er
-            elif t.state is None:
-                # Task is already finished and nothing await'ed on the task,
-                # so call the exception handler.
-                _exc_context["exception"] = exc
-                _exc_context["future"] = t
-                Loop.call_exception_handler(_exc_context)
-
-
-# Create a new task from a coroutine and run it until it finishes
-def run(coro):
-    """Create a new task from the given coroutine and run it until it completes.
-
-    Returns the value returned by *coro*.
-    """
-
-    return run_until_complete(create_task(coro))
-
-
-################################################################################
-# Event loop wrapper
-
-
-async def _stopper():
-    pass
-
-
-_stop_task = None
-
-
-class Loop:
-    """Class representing the event loop"""
-
-    _exc_handler = None
-
-    def create_task(coro):
-        """Create a task from the given *coro* and return the new `Task` object."""
-
-        return create_task(coro)
-
-    def run_forever():
-        """Run the event loop until `Loop.stop()` is called."""
-
-        global _stop_task
-        _stop_task = Task(_stopper(), globals())
-        run_until_complete(_stop_task)
-        # TODO should keep running until .stop() is called, even if there're no tasks left
-
-    def run_until_complete(aw):
-        """Run the given *awaitable* until it completes.  If *awaitable* is not a task then
-        it will be promoted to one.
-        """
-
-        return run_until_complete(_promote_to_task(aw))
-
-    def stop():
-        """Stop the event loop"""
-
-        global _stop_task
-        if _stop_task is not None:
-            _task_queue.push_head(_stop_task)
-            # If stop() is called again, do nothing
-            _stop_task = None
-
-    def close():
-        """Close the event loop."""
-
-        pass
-
-    def set_exception_handler(handler):
-        """Set the exception handler to call when a Task raises an exception that is not
-        caught.  The *handler* should accept two arguments: ``(loop, context)``
-        """
-
-        Loop._exc_handler = handler
-
-    def get_exception_handler():
-        """Get the current exception handler. Returns the handler, or ``None`` if no
-        custom handler is set.
-        """
-
-        return Loop._exc_handler
-
-    def default_exception_handler(loop, context):
-        """The default exception handler that is called."""
-
-        exc = context["exception"]
-        print_exception(None, exc, exc.__traceback__)
-
-    def call_exception_handler(context):
-        """Call the current exception handler. The argument *context* is passed through
-        and is a dictionary containing keys:
-        ``'message'``, ``'exception'``, ``'future'``
-        """
-        (Loop._exc_handler or Loop.default_exception_handler)(Loop, context)
-
-
-# The runq_len and waitq_len arguments are for legacy uasyncio compatibility
-def get_event_loop(runq_len=0, waitq_len=0):
-    """Return the event loop used to schedule and run tasks. See `Loop`."""
-
-    return Loop
-
-
-def current_task():
-    """Return the `Task` object associated with the currently running task."""
-
-    return cur_task
-
-
-def new_event_loop():
-    """Reset the event loop and return it.
-
-    **NOTE**: Since MicroPython only has a single event loop, this function just resets
-    the loop's state, it does not create a new one
-    """
-
-    global _task_queue, _io_queue, _exc_context, cur_task
-    # TaskQueue of Task instances
-    _task_queue = TaskQueue()
-    # Task queue and poller for stream IO
-    _io_queue = IOQueue()
-    cur_task = None
-    _exc_context['exception'] = None
-    _exc_context['future'] = None
-    return Loop
-
-
-# Initialise default event loop
-new_event_loop()
--- a/libs/circuitpython/asyncio/event.py
+++ b/libs/circuitpython/asyncio/event.py
@@ -1,92 +0,0 @@
-# SPDX-FileCopyrightText: 2019-2020 Damien P. George
-#
-# SPDX-License-Identifier: MIT
-#
-# MicroPython uasyncio module
-# MIT license; Copyright (c) 2019-2020 Damien P. George
-#
-# This code comes from MicroPython, and has not been run through black or pylint there.
-# Altering these files significantly would make merging difficult, so we will not use
-# pylint or black.
-# pylint: skip-file
-# fmt: off
-"""
-Events
-======
-"""
-
-from . import core
-
-# Event class for primitive events that can be waited on, set, and cleared
-class Event:
-    """Create a new event which can be used to synchronize tasks. Events
-    start in the cleared state.
-    """
-
-    def __init__(self):
-        self.state = False  # False=unset; True=set
-        self.waiting = core.TaskQueue()  # Queue of Tasks waiting on completion of this event
-
-    def is_set(self):
-        """Returns ``True`` if the event is set, ``False`` otherwise."""
-
-        return self.state
-
-    def set(self):
-        """Set the event. Any tasks waiting on the event will be scheduled to run.
-        """
-
-        # Event becomes set, schedule any tasks waiting on it
-        # Note: This must not be called from anything except the thread running
-        # the asyncio loop (i.e. neither hard or soft IRQ, or a different thread).
-        while self.waiting.peek():
-            core._task_queue.push_head(self.waiting.pop_head())
-        self.state = True
-
-    def clear(self):
-        """Clear the event."""
-
-        self.state = False
-
-    async def wait(self):
-        """Wait for the event to be set. If the event is already set then it returns
-        immediately.
-
-        This is a coroutine.
-        """
-
-        if not self.state:
-            # Event not set, put the calling task on the event's waiting queue
-            self.waiting.push_head(core.cur_task)
-            # Set calling task's data to the event's queue so it can be removed if needed
-            core.cur_task.data = self.waiting
-            await core._never()
-        return True
-
-
-# MicroPython-extension: This can be set from outside the asyncio event loop,
-# such as other threads, IRQs or scheduler context. Implementation is a stream
-# that asyncio will poll until a flag is set.
-# Note: Unlike Event, this is self-clearing.
-try:
-    import uio
-
-    class ThreadSafeFlag(uio.IOBase):
-        def __init__(self):
-            self._flag = 0
-
-        def ioctl(self, req, flags):
-            if req == 3:  # MP_STREAM_POLL
-                return self._flag * flags
-            return None
-
-        def set(self):
-            self._flag = 1
-
-        async def wait(self):
-            if not self._flag:
-                yield core._io_queue.queue_read(self)
-            self._flag = 0
-
-except ImportError:
-    pass
--- a/Show More
+++ b/Show More
				`@@ -1 +0,0 @@`
				`This directory contains examples that demonstrate basic and token authentication.`
				`@@ -1 +0,0 @@`
				`This directory contains Cross-Origin Resource Sharing (CORS) examples.`