Version 1.3.5.dev0

Bumps [urllib3](https://github.com/urllib3/urllib3) from 1.26.17 to 1.26.18.
- [Release notes](https://github.com/urllib3/urllib3/releases)
- [Changelog](https://github.com/urllib3/urllib3/blob/main/CHANGES.rst)
- [Commits](https://github.com/urllib3/urllib3/compare/1.26.17...1.26.18)

---
updated-dependencies:
- dependency-name: urllib3
  dependency-type: direct:production
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

.coveragerc

@@ -1,2 +1,5 @@
 [run]
-omit=src/utemplate/*
+omit=
+    src/microdot_websocket_alt.py
+    src/microdot_asgi_websocket.py
+    src/microdot_ssl.py

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,26 @@
+---
+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.

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+  - name: GitHub Discussions
+    url: https://github.com/miguelgrinberg/microdot/discussions
+    about: Ask questions here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+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.

.github/workflows/tests.yml

@@ -11,8 +11,8 @@ jobs:
     name: lint
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-python@v2
+      - 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 -eflake8
@@ -21,12 +21,12 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest, macos-latest, windows-latest]
-        python: ['3.6', '3.7', '3.8', '3.9', '3.10']
+        python: ['3.7', '3.8', '3.9', '3.10', '3.11']
       fail-fast: false
     runs-on: ${{ matrix.os }}
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-python@v2
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v3
         with:
           python-version: ${{ matrix.python }}
       - run: python -m pip install --upgrade pip wheel
@@ -36,8 +36,8 @@ jobs:
     name: tests-micropython
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-python@v2
+      - 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 -eupy
@@ -45,18 +45,21 @@ jobs:
     name: coverage
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-python@v2
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v3
       - run: python -m pip install --upgrade pip wheel
-      - run: pip install tox tox-gh-actions codecov
+      - run: pip install tox tox-gh-actions
       - run: tox
-      - run: codecov
+      - uses: codecov/codecov-action@v3
+        with:
+          files: ./coverage.xml
+          fail_ci_if_error: true
   benchmark:
     name: benchmark
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-python@v2
+      - 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 -ebenchmark

.gitignore

@@ -103,3 +103,8 @@ venv.bak/
 
 # mypy
 .mypy_cache/
+
+# other
+*.der
+*.pem
+*_txt.py

.readthedocs.yaml

@@ -0,0 +1,16 @@
+version: 2
+
+build:
+  os: ubuntu-22.04
+  tools:
+    python: "3.11"
+
+sphinx:
+  configuration: docs/conf.py
+
+python:
+  install:
+    - method: pip
+      path: .
+      extra_requirements:
+        - docs

CHANGES.md

@@ -1,5 +1,101 @@
 # Microdot change log
 
+**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))
+
+**Release 1.1.0** - 2022-09-17
+
+- Websocket support [#55](https://github.com/miguelgrinberg/microdot/issues/55) ([commit](https://github.com/miguelgrinberg/microdot/commit/2399c29c8a45289f009f47fd66438452da93cdab))
+- SSL/TLS support ([commit #1](https://github.com/miguelgrinberg/microdot/commit/b61f51f2434465b7a0ee197aabf46e8f99f6e8ad) [commit #2](https://github.com/miguelgrinberg/microdot/commit/fe750feb0373b41cb022521a6a3edf1973847a74))
+- Add `abort()` function ([commit](https://github.com/miguelgrinberg/microdot/commit/3c125c43d2e037ce64138e22c1ff4186ea107471))
+- Charset handling in Content-Type headers [#60](https://github.com/miguelgrinberg/microdot/issues/60) ([commit](https://github.com/miguelgrinberg/microdot/commit/75725795b45d275deaee133204e400e8fbb3de70))
+- Recover from errors writing the response ([commit](https://github.com/miguelgrinberg/microdot/commit/dc7a041ebd30f38b9f6b22c4bbcd61993c43944e))
+- Reorganized examples into subdirectories ([commit](https://github.com/miguelgrinberg/microdot/commit/a01fc9c3f070e21e705b8f12ceb8288b0f304569))
+- Update tests to use MicroPython 1.19 ([commit](https://github.com/miguelgrinberg/microdot/commit/42b6d6979381d9cd8ccc6ab6e079f12ec5987b80))
+- Update MicroPython libraries used by tests ([commit](https://github.com/miguelgrinberg/microdot/commit/e767426228eeacd58886bccb5046049e994c0479))
+- Fix links to hello and gpio examples in documentation [#53](https://github.com/miguelgrinberg/microdot/issues/53) ([commit](https://github.com/miguelgrinberg/microdot/commit/ec0f9ba855cca7dd35cddad40c4cb7eb17d8842a)) (thanks **Sterling G. Baird**!)
+
 **Release 1.0.0** - 2022-08-07
 
 - User sessions with signed JWTs ([commit](https://github.com/miguelgrinberg/microdot/commit/355ffefcb2697b30d03359d35283835901f375d6))

MANIFEST.in

@@ -0,0 +1,5 @@
+include README.md LICENSE tox.ini
+recursive-include docs *
+recursive-exclude docs/_build *
+recursive-include tests *
+exclude **/*.pyc

docs/_static/css/custom.css

@@ -1,3 +1,8 @@
-.py .class, .py .method, .py .property {
+.py.class, .py.function, .py.method, .py.property {
   margin-top: 20px;
 }
+
+div.sphinxsidebar {
+    max-height: 100%;
+    overflow-y: auto;
+}

docs/api.rst

@@ -13,6 +13,9 @@ API Reference
 .. autoclass:: microdot.Response
    :members:
 
+.. autoclass:: microdot.NoCaseDict
+   :members:
+
 .. autoclass:: microdot.MultiDict
    :members:
 
@@ -49,6 +52,36 @@ API Reference
 .. automodule:: microdot_session
    :members:
 
+``microdot_cors`` module
+------------------------
+
+.. automodule:: microdot_cors
+   :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
 -------------------------------
 

docs/extensions.rst

@@ -23,7 +23,7 @@ Asynchronous Support with Asyncio
        | MicroPython: `uasyncio <https://github.com/micropython/micropython/tree/master/extmod/uasyncio>`_
 
    * - Examples
-     - | `hello_async.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/hello_async.py>`_
+     - | `hello_async.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/hello/hello_async.py>`_
 
 Microdot can be extended to use an asynchronous programming model based on the
 ``asyncio`` package. When the :class:`Microdot <microdot_asyncio.Microdot>`
@@ -68,8 +68,8 @@ Using the uTemplate Engine
      - | `utemplate <https://github.com/pfalcon/utemplate/tree/master/utemplate>`_
 
    * - Examples
-     - | `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>`_
+     - | `hello.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/templates/utemplate/hello.py>`_
+       | `hello_utemplate_async.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/hello/hello_utemplate_async.py>`_
 
 The :func:`render_template <microdot_utemplate.render_template>` function is
 used to render HTML templates with the uTemplate engine. The first argument is
@@ -110,7 +110,7 @@ Using the Jinja Engine
      - | `Jinja2 <https://jinja.palletsprojects.com/>`_
 
    * - Examples
-     - | `hello_jinja.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/hello_jinja.py>`_
+     - | `hello.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/templates/jinja/hello.py>`_
 
 The :func:`render_template <microdot_jinja.render_template>` function is used
 to render HTML templates with the Jinja engine. The first argument is the
@@ -137,8 +137,8 @@ subdirectory. This location can be changed with the
 .. note::
     The Jinja extension is not compatible with MicroPython.
 
-Maintaing Secure User Sessions
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Maintaining Secure User Sessions
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 .. list-table::
    :align: left
@@ -152,13 +152,11 @@ Maintaing Secure User Sessions
 
    * - Required external dependencies
      - | CPython: `PyJWT <https://pyjwt.readthedocs.io/>`_
-       | MicroPython: `jwt.py <https://github.com/miguelgrinberg/micropython-lib/blob/ujwt-module/python-ecosys/ujwt/ujwt.py>`_,
-                      `hmac <https://github.com/micropython/micropython-lib/blob/master/python-stdlib/hmac/hmac.py>`_,
-                      `hashlib <https://github.com/miguelgrinberg/micropython-lib/blob/ujwt-module/python-stdlib/hashlib>`_,
-                      `warnings <https://github.com/micropython/micropython-lib/blob/master/python-stdlib/warnings/warnings.py>`_
+       | MicroPython: `jwt.py <https://github.com/micropython/micropython-lib/blob/master/python-ecosys/pyjwt/jwt.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/login.py>`_
+     - | `login.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/sessions/login.py>`_
 
 The session extension provides a secure way for the application to maintain
 user sessions. The session is stored as a signed cookie in the client's
@@ -210,6 +208,161 @@ Example::
         delete_session(req)
         return redirect('/')
 
+Cross-Origin Resource Sharing (CORS)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. list-table::
+   :align: left
+
+   * - Compatibility
+     - | CPython & MicroPython
+
+   * - Required Microdot source files
+     - | `microdot.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot.py>`_
+       | `microdot_cors.py <https://github.com/miguelgrinberg/microdot/tree/main/src/microdot_cors.py>`_
+
+   * - Required external dependencies
+     - | None
+
+   * - Examples
+     - | `cors.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/cors/cors.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``.
+
+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
+
+    app = Microdot()
+    cors = CORS(app, allowed_origins=['https://example.com'],
+                allow_credentials=True)
+
+WebSocket Support
+~~~~~~~~~~~~~~~~~
+
+.. list-table::
+   :align: left
+
+   * - Compatibility
+     - | CPython & MicroPython
+
+   * - Required Microdot source files
+     - | `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
+     - | `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 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.
+
+Example::
+
+        @app.route('/echo')
+        @with_websocket
+        def echo(request, ws):
+            while True:
+                message = ws.receive()
+                ws.send(message)
+
+.. note::
+   An unsupported *microdot_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.
+
+Asynchronous WebSocket
+~~~~~~~~~~~~~~~~~~~~~~
+
+.. list-table::
+   :align: left
+
+   * - Compatibility
+     - | CPython & MicroPython
+
+   * - 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_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: None
+       | MicroPython: `uasyncio <https://github.com/micropython/micropython/tree/master/extmod/uasyncio>`_
+
+   * - Examples
+     - | `echo_async.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/websocket/echo_async.py>`_
+
+This extension has the same interface as the synchronous WebSocket extension,
+but the ``receive()`` and ``send()`` methods are asynchronous.
+
+.. note::
+   An unsupported *microdot_asgi_websocket.py* module, with the same
+   interface, is also provided. This module must be used instead of
+   *microdot_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.
+
+HTTPS Support
+~~~~~~~~~~~~~
+
+.. list-table::
+   :align: left
+
+   * - Compatibility
+     - | CPython & MicroPython
+
+   * - Required Microdot source files
+     - | `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
+     - | `hello_tls.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/tls/hello_tls.py>`_
+       | `hello_async_tls.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/tls/hello_async_tls.py>`_
+
+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.
+
+Example::
+
+    from microdot import Microdot
+    from microdot_ssl import create_ssl_context
+
+    app = Microdot()
+
+    @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
 ~~~~~~~~~~~
 
@@ -306,7 +459,7 @@ Using a WSGI Web Server
      - | A WSGI web server, such as `Gunicorn <https://gunicorn.org/>`_.
 
    * - Examples
-     - | `hello_wsgi.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/hello_wsgi.py>`_
+     - | `hello_wsgi.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/hello/hello_wsgi.py>`_
 
 
 The ``microdot_wsgi`` module provides an extended ``Microdot`` class that
@@ -333,6 +486,9 @@ web application using the Gunicorn web server::
 
     gunicorn test:app
 
+When using this WSGI adapter, the ``environ`` dictionary provided by the web
+server is available to request handlers as ``request.environ``.
+
 Using an ASGI Web Server
 ^^^^^^^^^^^^^^^^^^^^^^^^
 
@@ -351,7 +507,7 @@ Using an ASGI Web Server
      - | 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>`_
+     - | `hello_asgi.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/hello/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
@@ -376,3 +532,5 @@ web application using the Uvicorn web server::
 
     uvicorn test:app
 
+When using this ASGI adapter, the ``scope`` dictionary provided by the web
+server is available to request handlers as ``request.asgi_scope``.

docs/intro.rst

@@ -68,7 +68,7 @@ Running with CPython
      - | None
 
    * - Examples
-     - | `hello.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/hello.py>`_
+     - | `hello.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/hello/hello.py>`_
 
 When using CPython, you can start the web server by running the script that
 defines and runs the application instance::
@@ -93,8 +93,8 @@ Running with MicroPython
      - | None
 
    * - Examples
-     - | `hello.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/hello.py>`_
-       | `gpio.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/gpio.py>`_
+     - | `hello.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/hello/hello.py>`_
+       | `gpio.py <https://github.com/miguelgrinberg/microdot/blob/main/examples/gpio/gpio.py>`_
 
 When using MicroPython, you can upload a *main.py* file containing the web
 server code to your device along with *microdot.py*. MicroPython will
@@ -283,7 +283,7 @@ handled::
     def start_timer(request):
         request.g.start_time = time.time()
 
-    @ap.after_request
+    @app.after_request
     def end_timer(request, response):
         duration = time.time() - request.g.start_time
         print(f'Request took {duration:0.2f} seconds')
@@ -293,9 +293,15 @@ The function can return a modified response object to replace the original. If
 the function does not return a value, then the original response object is
 used.
 
+The after request handlers are only invoked for successful requests. The
+:func:`after_error_request() <microdot.Microdot.after_error_request>`
+decorator can be used to register a function that is called after an error
+occurs. The function receives the request and the error response and is
+expected to return an updated response object.
+
 .. note::
    The :ref:`request.g <The "g" Object>` object is a special object that allows
-   the before and after request handlers, as well sa the route function to
+   the before and after request handlers, as well as the route function to
    share data during the life of the request.
 
 Error Handlers
@@ -314,7 +320,7 @@ automatically handled by Microdot are:
 While the above errors are fully complaint with the HTTP specification, the
 application might want to provide custom responses for them. The
 :func:`errorhandler() <microdot.Microdot.errorhandler>` decorator registers
-a functions to respond to specific error codes. The following example shows a
+functions to respond to specific error codes. The following example shows a
 custom error handler for 404 errors::
 
     @app.errorhandler(404)
@@ -322,14 +328,18 @@ custom error handler for 404 errors::
         return {'error': 'resource not found'}, 404
 
 The ``errorhandler()`` decorator has a second form, in which it takes an
-exception class as an argument. Microdot will then invoke the handler when an
-exception of that class is raised. The next example provides a custom response
-for division by zero errors::
+exception class as an argument. Microdot will then invoke the handler when the
+exception is an instance of the given class is raised. The next example
+provides a custom response for division by zero errors::
 
     @app.errorhandler(ZeroDivisionError)
-    def division_by_zero(request):
+    def division_by_zero(request, exception):
         return {'error': 'division by zero'}, 500
 
+When the raised exception class does not have an error handler defined, but
+one or more of its base classes do, Microdot makes an attempt to invoke the
+most specific handler.
+
 Mounting a Sub-Application
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
@@ -490,7 +500,7 @@ contents as a file-like object.
 Cookies
 ^^^^^^^
 
-Cookies that are sent by the client are made available throught the
+Cookies that are sent by the client are made available through the
 :attr:`cookies <microdot.Request.cookies>` attribute of the request object in
 dictionary form.
 
@@ -585,7 +595,7 @@ always returned to the client in the response body::
 In the above example, Microdot issues a standard 200 status code response, and
 inserts the necessary headers.
 
-The applicaton can provide its own status code as a second value returned from
+The application can provide its own status code as a second value returned from
 the route. The example below returns a 202 status code::
 
     @app.get('/')
@@ -601,7 +611,7 @@ The next example returns an HTML response, instead of a default text response::
         return '<h1>Hello, World!</h1>', 202, {'Content-Type': 'text/html'}
 
 If the application needs to return custom headers, but does not need to change
-the default status code, then it can return two values, omitting the stauts
+the default status code, then it can return two values, omitting the status
 code::
 
     @app.get('/')
@@ -652,6 +662,15 @@ object for a file::
         def index(request):
             return send_file('/static/index.html')
 
+A suggested caching duration can be returned to the client in the ``max_age``
+argument::
+
+        from microdot import send_file
+
+        @app.get('/')
+        def image(request):
+            return send_file('/static/image.jpg', max_age=3600)  # in seconds
+
 .. note::
    Unlike other web frameworks, Microdot does not automatically configure a
    route to serve static files. The following is an example route that can be
@@ -663,7 +682,7 @@ object for a file::
             if '..' in path:
                 # directory traversal is not allowed
                 return 'Not found', 404
-            return send_file('static/' + path)
+            return send_file('static/' + path, max_age=86400)
 
 Streaming Responses
 ^^^^^^^^^^^^^^^^^^^
@@ -734,7 +753,7 @@ Another option is to create a response object directly in the route function::
    Standard cookies do not offer sufficient privacy and security controls, so
    never store sensitive information in them unless you are adding additional
    protection mechanisms such as encryption or cryptographic signing. The
-   :ref:`session <Maintaing Secure User Sessions>` extension implements signed
+   :ref:`session <Maintaining Secure User Sessions>` extension implements signed
    cookies that prevent tampering by malicious actors.
 
 Concurrency

examples/benchmark/requirements.txt

@@ -1,11 +1,11 @@
 aiofiles==0.8.0
 anyio==3.6.1
 blinker==1.5
-certifi==2022.6.15
+certifi==2023.7.22
 charset-normalizer==2.1.0
 click==8.1.3
 fastapi==0.79.0
-Flask==2.2.1
+Flask==2.3.2
 gunicorn==20.1.0
 h11==0.13.0
 h2==4.1.0
@@ -22,12 +22,12 @@ priority==2.0.0
 psutil==5.9.1
 pydantic==1.9.1
 quart==0.18.0
-requests==2.28.1
+requests==2.31.0
 sniffio==1.2.0
-starlette==0.19.1
+starlette==0.27.0
 toml==0.10.2
 typing_extensions==4.3.0
-urllib3==1.26.11
+urllib3==1.26.18
 uvicorn==0.18.2
-Werkzeug==2.2.1
+Werkzeug==2.2.3
 wsproto==1.1.0

examples/benchmark/results.txt

@@ -1,14 +0,0 @@
-❯ 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}%

examples/benchmark/run.py

@@ -1,6 +1,7 @@
 import os
 import subprocess
 import time
+from timeit import timeit
 import requests
 import psutil
 import humanize
@@ -76,19 +77,23 @@ apps = [
 for app, env, name in apps:
     p = subprocess.Popen(
         app.split() if isinstance(app, str) else app,
-        env={'PATH': os.environ['PATH'], **env},
+        env={'PATH': os.environ['PATH'] + ':../../bin', **env},
         stdout=subprocess.DEVNULL,
         stderr=subprocess.DEVNULL
     )
     time.sleep(1)
+    tm = 0
     if not name.startswith('baseline'):
-        r = requests.get('http://localhost:5000')
-        r.raise_for_status()
+        def req():
+            r = requests.get('http://localhost:5000')
+            r.raise_for_status()
+
+        tm = timeit(req, number=1000)
     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}{humanize.naturalsize(mem):>10} {bar}')
+    print(f'{name:<28}{tm:10.2f}s {humanize.naturalsize(mem):>10} {bar}')
     p.terminate()
     time.sleep(1)

examples/cors/README.md

@@ -0,0 +1 @@
+This directory contains Cross-Origin Resource Sharing (CORS) examples.

examples/cors/app.py

@@ -0,0 +1,14 @@
+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()

examples/gpio/gpio.html

@@ -2,6 +2,7 @@
 <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) {

examples/hello/README.md

@@ -0,0 +1,2 @@
+This directory contains several "Hello, World!" type examples for different
+platforms and configurations supported by Microdot.

examples/hello/hello.py

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

examples/hello/hello_asgi.py

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

examples/hello/hello_async.py

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

examples/hello/hello_wsgi.py

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

examples/sessions/README.md

@@ -0,0 +1 @@
+This directory contains examples that take advantage of user sessions.

examples/sessions/login.py

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

examples/static/README.md

@@ -0,0 +1,2 @@
+The example in this directory demonstrates how to serve static files out of a
+directory.

examples/static/gzstatic.py

@@ -0,0 +1,20 @@
+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)

examples/static/static/index.html

@@ -2,6 +2,7 @@
 <html>
   <head>
     <title>Static File Serving Demo</title>
+    <meta charset="UTF-8">
   </head>
   <body>
     <h1>Static File Serving Demo</h1>

examples/static/static_async.py

@@ -0,0 +1,18 @@
+from microdot_asyncio import Microdot, send_file
+app = Microdot()
+
+
+@app.route('/')
+async def index(request):
+    return send_file('static/index.html')
+
+
+@app.route('/static/<path:path>')
+async def static(request, path):
+    if '..' in path:
+        # directory traversal is not allowed
+        return 'Not found', 404
+    return send_file('static/' + path)
+
+
+app.run(debug=True)

examples/streaming/README.md

@@ -0,0 +1 @@
+This directory contain examples that demonstrate how to use streaming responses.

examples/streaming/video_stream.py

@@ -19,6 +19,7 @@ def index(request):
 <html>
   <head>
     <title>Microdot Video Streaming</title>
+    <meta charset="UTF-8">
   </head>
   <body>
     <h1>Microdot Video Streaming</h1>

examples/streaming/video_stream_async.py

@@ -21,6 +21,7 @@ def index(request):
 <html>
   <head>
     <title>Microdot Video Streaming</title>
+    <meta charset="UTF-8">
   </head>
   <body>
     <h1>Microdot Video Streaming</h1>

examples/templates/jinja/bootstrap.py

@@ -0,0 +1,19 @@
+from microdot import Microdot, Response
+from microdot_jinja import render_template
+
+app = Microdot()
+Response.default_content_type = 'text/html'
+
+
+@app.route('/')
+def index(req):
+    return render_template('page1.html', page='Page 1')
+
+
+@app.route('/page2')
+def page2(req):
+    return render_template('page2.html', page='Page 2')
+
+
+if __name__ == '__main__':
+    app.run()

examples/templates/jinja/hello.py

@@ -10,7 +10,7 @@ def index(req):
     name = None
     if req.method == 'POST':
         name = req.form.get('name')
-    return render_template('index_jinja.html', name=name)
+    return render_template('index.html', name=name)
 
 
 if __name__ == '__main__':

examples/templates/jinja/templates/base.html

@@ -0,0 +1,48 @@
+<!--
+  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>

examples/templates/jinja/templates/index.html

@@ -2,6 +2,7 @@
 <html>
   <head>
     <title>Microdot + Jinja example</title>
+    <meta charset="UTF-8">
   </head>
   <body>
     <h1>Microdot + Jinja example</h1>

examples/templates/jinja/templates/page1.html

@@ -0,0 +1,6 @@
+{% extends 'base.html' %}
+
+{% block content %}
+<h2>This is {{ page }}</h2>
+<p>Go to <a href="/page2">Page 2</a>.</p>
+{% endblock %}

examples/templates/jinja/templates/page2.html

@@ -0,0 +1,6 @@
+{% extends 'base.html' %}
+
+{% block content %}
+<h2>This is {{ page }}</h2>
+<p>Go back <a href="/">Page 1</a>.</p>
+{% endblock %}

examples/templates/utemplate/bootstrap.py

@@ -0,0 +1,19 @@
+from microdot import Microdot, Response
+from microdot_utemplate import render_template
+
+app = Microdot()
+Response.default_content_type = 'text/html'
+
+
+@app.route('/')
+def index(req):
+    return render_template('page1.html', page='Page 1')
+
+
+@app.route('/page2')
+def page2(req):
+    return render_template('page2.html', page='Page 2')
+
+
+if __name__ == '__main__':
+    app.run(debug=True)

examples/templates/utemplate/hello.py

@@ -10,7 +10,7 @@ def index(req):
     name = None
     if req.method == 'POST':
         name = req.form.get('name')
-    return render_template('index_utemplate.html', name=name)
+    return render_template('index.html', name=name)
 
 
 if __name__ == '__main__':

examples/templates/utemplate/templates/base_footer.html

@@ -0,0 +1,14 @@
+    </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>

examples/templates/utemplate/templates/base_header.html

@@ -0,0 +1,33 @@
+<!--
+  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>

examples/templates/utemplate/templates/index.html

@@ -3,6 +3,7 @@
 <html>
   <head>
     <title>Microdot + uTemplate example</title>
+    <meta charset="UTF-8">
   </head>
   <body>
     <h1>Microdot + uTemplate example</h1>

examples/templates/utemplate/templates/page1.html

@@ -0,0 +1,7 @@
+{% 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' %}

examples/templates/utemplate/templates/page2.html

@@ -0,0 +1,7 @@
+{% args page %}
+{% include 'base_header.html' %}
+
+<h2>This is {{ page }}</h2>
+<p>Go back <a href="/">Page 1</a>.</p>
+
+{% include 'base_footer.html' %}

examples/tls/README.md

@@ -0,0 +1,20 @@
+This directory contains examples that demonstrate how to start TLS servers.
+
+To run these examples, SSL certificate and private key files need to be
+created. When running under CPython, the files should be in PEM format, named
+`cert.pem` and `key.pem`. When running under MicroPython, they should be in DER
+format, and named `cert.der` and `key.der`.
+
+To quickly create a self-signed SSL certificate, use the following command:
+
+```bash
+openssl req -x509 -newkey rsa:4096 -nodes -out cert.pem -keyout key.pem -days 365
+```
+
+To convert the resulting PEM files to DER format for MicroPython, use these
+commands:
+
+```bash
+openssl x509 -in cert.pem -out cert.der -outform DER
+openssl rsa -in key.pem -out key.der -outform DER
+```

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)

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)

examples/tls/hello_async_tls.py

@@ -0,0 +1,36 @@
+import ssl
+from microdot_asyncio import Microdot
+
+app = Microdot()
+
+htmldoc = '''<!DOCTYPE html>
+<html>
+    <head>
+        <title>Microdot Example Page</title>
+        <meta charset="UTF-8">
+    </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...'
+
+
+sslctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+sslctx.load_cert_chain('cert.pem', 'key.pem')
+app.run(port=4443, debug=True, ssl=sslctx)

examples/tls/hello_tls.py

@@ -0,0 +1,37 @@
+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>
+        <meta charset="UTF-8">
+    </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)

examples/tls/index.html

@@ -0,0 +1,36 @@
+<!doctype html>
+<html>
+  <head>
+    <title>Microdot TLS WebSocket Demo</title>
+    <meta charset="UTF-8">
+  </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>

examples/uploads/README.md

@@ -0,0 +1 @@
+This directory contains file upload examples.

examples/uploads/files/README.md

@@ -0,0 +1 @@
+Uploaded files are saved to this directory.

examples/uploads/index.html

@@ -0,0 +1,35 @@
+<!doctype html>
+<html>
+  <head>
+    <title>Microdot Upload Example</title>
+    <meta charset="UTF-8">
+  </head>
+  <body>
+    <h1>Microdot Upload Example</h1>
+    <form id="form">
+      <input type="file" id="file" name="file" />
+      <input type="submit" value="Upload" />
+    </form>
+    <script>
+      async function upload(ev) {
+        ev.preventDefault();
+        const file = document.getElementById('file').files[0];
+        if (!file) {
+          return;
+        }
+        await fetch('/upload', {
+          method: 'POST',
+          body: file,
+          headers: {
+            'Content-Type': 'application/octet-stream',
+            'Content-Disposition': `attachment; filename="${file.name}"`,
+          },
+        }).then(res => {
+          console.log('Upload accepted');
+          window.location.href = '/';
+        });
+      }
+      document.getElementById('form').addEventListener('submit', upload);
+    </script>
+  </body>
+</html>

examples/uploads/uploads.py

@@ -0,0 +1,34 @@
+from microdot import Microdot, send_file, Request
+
+app = Microdot()
+Request.max_content_length = 1024 * 1024  # 1MB (change as needed)
+
+
+@app.get('/')
+def index(request):
+    return send_file('index.html')
+
+
+@app.post('/upload')
+def upload(request):
+    # obtain the filename and size from request headers
+    filename = request.headers['Content-Disposition'].split(
+        'filename=')[1].strip('"')
+    size = int(request.headers['Content-Length'])
+
+    # sanitize the filename
+    filename = filename.replace('/', '_')
+
+    # write the file to the files directory in 1K chunks
+    with open('files/' + filename, 'wb') as f:
+        while size > 0:
+            chunk = request.stream.read(min(size, 1024))
+            f.write(chunk)
+            size -= len(chunk)
+
+    print('Successfully saved file: ' + filename)
+    return ''
+
+
+if __name__ == '__main__':
+    app.run(debug=True)

examples/uploads/uploads_async.py

@@ -0,0 +1,34 @@
+from microdot_asyncio import Microdot, send_file, Request
+
+app = Microdot()
+Request.max_content_length = 1024 * 1024  # 1MB (change as needed)
+
+
+@app.get('/')
+async def index(request):
+    return send_file('index.html')
+
+
+@app.post('/upload')
+async def upload(request):
+    # obtain the filename and size from request headers
+    filename = request.headers['Content-Disposition'].split(
+        'filename=')[1].strip('"')
+    size = int(request.headers['Content-Length'])
+
+    # sanitize the filename
+    filename = filename.replace('/', '_')
+
+    # 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))
+            f.write(chunk)
+            size -= len(chunk)
+
+    print('Successfully saved file: ' + filename)
+    return ''
+
+
+if __name__ == '__main__':
+    app.run(debug=True)

examples/websocket/README.md

@@ -0,0 +1 @@
+This directory contains WebSocket examples.

examples/websocket/echo.py

@@ -0,0 +1,20 @@
+from microdot import Microdot, send_file
+from microdot_websocket import with_websocket
+
+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)
+
+
+app.run()

examples/websocket/echo_asgi.py

@@ -0,0 +1,17 @@
+from microdot_asgi import Microdot, send_file
+from microdot_asgi_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)

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()

examples/websocket/echo_wsgi.py

@@ -0,0 +1,17 @@
+from microdot_wsgi import Microdot, send_file
+from microdot_websocket import with_websocket
+
+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)

examples/websocket/index.html

@@ -0,0 +1,36 @@
+<!doctype html>
+<html>
+  <head>
+    <title>Microdot WebSocket Demo</title>
+    <meta charset="UTF-8">
+  </head>
+  <body>
+    <h1>Microdot 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('ws://' + 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>

libs/micropython/hashlib/__init__.py

@@ -1,25 +0,0 @@
-try:
-    import uhashlib
-except ImportError:
-    uhashlib = None
-
-
-def init():
-    for i in ("sha1", "sha224", "sha256", "sha384", "sha512"):
-        try:
-            c = __import__("_" + i, None, None, (), 1)
-        except ImportError:
-            c = uhashlib
-        c = getattr(c, i, None)
-        globals()[i] = c
-
-
-init()
-
-
-def new(algo, data=b""):
-    try:
-        c = globals()[algo]
-        return c(data)
-    except KeyError:
-        raise ValueError(algo)

libs/micropython/hashlib/_sha224.py

@@ -1 +0,0 @@
-from ._sha256 import sha224

libs/micropython/hashlib/_sha256.py

@@ -1,301 +0,0 @@
-SHA_BLOCKSIZE = 64
-SHA_DIGESTSIZE = 32
-
-
-def new_shaobject():
-    return {
-        "digest": [0] * 8,
-        "count_lo": 0,
-        "count_hi": 0,
-        "data": [0] * SHA_BLOCKSIZE,
-        "local": 0,
-        "digestsize": 0,
-    }
-
-
-ROR = lambda x, y: (((x & 0xFFFFFFFF) >> (y & 31)) | (x << (32 - (y & 31)))) & 0xFFFFFFFF
-Ch = lambda x, y, z: (z ^ (x & (y ^ z)))
-Maj = lambda x, y, z: (((x | y) & z) | (x & y))
-S = lambda x, n: ROR(x, n)
-R = lambda x, n: (x & 0xFFFFFFFF) >> n
-Sigma0 = lambda x: (S(x, 2) ^ S(x, 13) ^ S(x, 22))
-Sigma1 = lambda x: (S(x, 6) ^ S(x, 11) ^ S(x, 25))
-Gamma0 = lambda x: (S(x, 7) ^ S(x, 18) ^ R(x, 3))
-Gamma1 = lambda x: (S(x, 17) ^ S(x, 19) ^ R(x, 10))
-
-
-def sha_transform(sha_info):
-    W = []
-
-    d = sha_info["data"]
-    for i in range(0, 16):
-        W.append((d[4 * i] << 24) + (d[4 * i + 1] << 16) + (d[4 * i + 2] << 8) + d[4 * i + 3])
-
-    for i in range(16, 64):
-        W.append((Gamma1(W[i - 2]) + W[i - 7] + Gamma0(W[i - 15]) + W[i - 16]) & 0xFFFFFFFF)
-
-    ss = sha_info["digest"][:]
-
-    def RND(a, b, c, d, e, f, g, h, i, ki):
-        t0 = h + Sigma1(e) + Ch(e, f, g) + ki + W[i]
-        t1 = Sigma0(a) + Maj(a, b, c)
-        d += t0
-        h = t0 + t1
-        return d & 0xFFFFFFFF, h & 0xFFFFFFFF
-
-    ss[3], ss[7] = RND(ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 0, 0x428A2F98)
-    ss[2], ss[6] = RND(ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 1, 0x71374491)
-    ss[1], ss[5] = RND(ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 2, 0xB5C0FBCF)
-    ss[0], ss[4] = RND(ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 3, 0xE9B5DBA5)
-    ss[7], ss[3] = RND(ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 4, 0x3956C25B)
-    ss[6], ss[2] = RND(ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 5, 0x59F111F1)
-    ss[5], ss[1] = RND(ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 6, 0x923F82A4)
-    ss[4], ss[0] = RND(ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 7, 0xAB1C5ED5)
-    ss[3], ss[7] = RND(ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 8, 0xD807AA98)
-    ss[2], ss[6] = RND(ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 9, 0x12835B01)
-    ss[1], ss[5] = RND(ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 10, 0x243185BE)
-    ss[0], ss[4] = RND(ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 11, 0x550C7DC3)
-    ss[7], ss[3] = RND(ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 12, 0x72BE5D74)
-    ss[6], ss[2] = RND(ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 13, 0x80DEB1FE)
-    ss[5], ss[1] = RND(ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 14, 0x9BDC06A7)
-    ss[4], ss[0] = RND(ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 15, 0xC19BF174)
-    ss[3], ss[7] = RND(ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 16, 0xE49B69C1)
-    ss[2], ss[6] = RND(ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 17, 0xEFBE4786)
-    ss[1], ss[5] = RND(ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 18, 0x0FC19DC6)
-    ss[0], ss[4] = RND(ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 19, 0x240CA1CC)
-    ss[7], ss[3] = RND(ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 20, 0x2DE92C6F)
-    ss[6], ss[2] = RND(ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 21, 0x4A7484AA)
-    ss[5], ss[1] = RND(ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 22, 0x5CB0A9DC)
-    ss[4], ss[0] = RND(ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 23, 0x76F988DA)
-    ss[3], ss[7] = RND(ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 24, 0x983E5152)
-    ss[2], ss[6] = RND(ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 25, 0xA831C66D)
-    ss[1], ss[5] = RND(ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 26, 0xB00327C8)
-    ss[0], ss[4] = RND(ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 27, 0xBF597FC7)
-    ss[7], ss[3] = RND(ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 28, 0xC6E00BF3)
-    ss[6], ss[2] = RND(ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 29, 0xD5A79147)
-    ss[5], ss[1] = RND(ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 30, 0x06CA6351)
-    ss[4], ss[0] = RND(ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 31, 0x14292967)
-    ss[3], ss[7] = RND(ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 32, 0x27B70A85)
-    ss[2], ss[6] = RND(ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 33, 0x2E1B2138)
-    ss[1], ss[5] = RND(ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 34, 0x4D2C6DFC)
-    ss[0], ss[4] = RND(ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 35, 0x53380D13)
-    ss[7], ss[3] = RND(ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 36, 0x650A7354)
-    ss[6], ss[2] = RND(ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 37, 0x766A0ABB)
-    ss[5], ss[1] = RND(ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 38, 0x81C2C92E)
-    ss[4], ss[0] = RND(ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 39, 0x92722C85)
-    ss[3], ss[7] = RND(ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 40, 0xA2BFE8A1)
-    ss[2], ss[6] = RND(ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 41, 0xA81A664B)
-    ss[1], ss[5] = RND(ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 42, 0xC24B8B70)
-    ss[0], ss[4] = RND(ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 43, 0xC76C51A3)
-    ss[7], ss[3] = RND(ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 44, 0xD192E819)
-    ss[6], ss[2] = RND(ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 45, 0xD6990624)
-    ss[5], ss[1] = RND(ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 46, 0xF40E3585)
-    ss[4], ss[0] = RND(ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 47, 0x106AA070)
-    ss[3], ss[7] = RND(ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 48, 0x19A4C116)
-    ss[2], ss[6] = RND(ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 49, 0x1E376C08)
-    ss[1], ss[5] = RND(ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 50, 0x2748774C)
-    ss[0], ss[4] = RND(ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 51, 0x34B0BCB5)
-    ss[7], ss[3] = RND(ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 52, 0x391C0CB3)
-    ss[6], ss[2] = RND(ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 53, 0x4ED8AA4A)
-    ss[5], ss[1] = RND(ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 54, 0x5B9CCA4F)
-    ss[4], ss[0] = RND(ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 55, 0x682E6FF3)
-    ss[3], ss[7] = RND(ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 56, 0x748F82EE)
-    ss[2], ss[6] = RND(ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 57, 0x78A5636F)
-    ss[1], ss[5] = RND(ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 58, 0x84C87814)
-    ss[0], ss[4] = RND(ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 59, 0x8CC70208)
-    ss[7], ss[3] = RND(ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 60, 0x90BEFFFA)
-    ss[6], ss[2] = RND(ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 61, 0xA4506CEB)
-    ss[5], ss[1] = RND(ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 62, 0xBEF9A3F7)
-    ss[4], ss[0] = RND(ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 63, 0xC67178F2)
-
-    dig = []
-    for i, x in enumerate(sha_info["digest"]):
-        dig.append((x + ss[i]) & 0xFFFFFFFF)
-    sha_info["digest"] = dig
-
-
-def sha_init():
-    sha_info = new_shaobject()
-    sha_info["digest"] = [
-        0x6A09E667,
-        0xBB67AE85,
-        0x3C6EF372,
-        0xA54FF53A,
-        0x510E527F,
-        0x9B05688C,
-        0x1F83D9AB,
-        0x5BE0CD19,
-    ]
-    sha_info["count_lo"] = 0
-    sha_info["count_hi"] = 0
-    sha_info["local"] = 0
-    sha_info["digestsize"] = 32
-    return sha_info
-
-
-def sha224_init():
-    sha_info = new_shaobject()
-    sha_info["digest"] = [
-        0xC1059ED8,
-        0x367CD507,
-        0x3070DD17,
-        0xF70E5939,
-        0xFFC00B31,
-        0x68581511,
-        0x64F98FA7,
-        0xBEFA4FA4,
-    ]
-    sha_info["count_lo"] = 0
-    sha_info["count_hi"] = 0
-    sha_info["local"] = 0
-    sha_info["digestsize"] = 28
-    return sha_info
-
-
-def getbuf(s):
-    if isinstance(s, str):
-        return s.encode("ascii")
-    else:
-        return bytes(s)
-
-
-def sha_update(sha_info, buffer):
-    if isinstance(buffer, str):
-        raise TypeError("Unicode strings must be encoded before hashing")
-    count = len(buffer)
-    buffer_idx = 0
-    clo = (sha_info["count_lo"] + (count << 3)) & 0xFFFFFFFF
-    if clo < sha_info["count_lo"]:
-        sha_info["count_hi"] += 1
-    sha_info["count_lo"] = clo
-
-    sha_info["count_hi"] += count >> 29
-
-    if sha_info["local"]:
-        i = SHA_BLOCKSIZE - sha_info["local"]
-        if i > count:
-            i = count
-
-        # copy buffer
-        for x in enumerate(buffer[buffer_idx : buffer_idx + i]):
-            sha_info["data"][sha_info["local"] + x[0]] = x[1]
-
-        count -= i
-        buffer_idx += i
-
-        sha_info["local"] += i
-        if sha_info["local"] == SHA_BLOCKSIZE:
-            sha_transform(sha_info)
-            sha_info["local"] = 0
-        else:
-            return
-
-    while count >= SHA_BLOCKSIZE:
-        # copy buffer
-        sha_info["data"] = list(buffer[buffer_idx : buffer_idx + SHA_BLOCKSIZE])
-        count -= SHA_BLOCKSIZE
-        buffer_idx += SHA_BLOCKSIZE
-        sha_transform(sha_info)
-
-    # copy buffer
-    pos = sha_info["local"]
-    sha_info["data"][pos : pos + count] = list(buffer[buffer_idx : buffer_idx + count])
-    sha_info["local"] = count
-
-
-def sha_final(sha_info):
-    lo_bit_count = sha_info["count_lo"]
-    hi_bit_count = sha_info["count_hi"]
-    count = (lo_bit_count >> 3) & 0x3F
-    sha_info["data"][count] = 0x80
-    count += 1
-    if count > SHA_BLOCKSIZE - 8:
-        # zero the bytes in data after the count
-        sha_info["data"] = sha_info["data"][:count] + ([0] * (SHA_BLOCKSIZE - count))
-        sha_transform(sha_info)
-        # zero bytes in data
-        sha_info["data"] = [0] * SHA_BLOCKSIZE
-    else:
-        sha_info["data"] = sha_info["data"][:count] + ([0] * (SHA_BLOCKSIZE - count))
-
-    sha_info["data"][56] = (hi_bit_count >> 24) & 0xFF
-    sha_info["data"][57] = (hi_bit_count >> 16) & 0xFF
-    sha_info["data"][58] = (hi_bit_count >> 8) & 0xFF
-    sha_info["data"][59] = (hi_bit_count >> 0) & 0xFF
-    sha_info["data"][60] = (lo_bit_count >> 24) & 0xFF
-    sha_info["data"][61] = (lo_bit_count >> 16) & 0xFF
-    sha_info["data"][62] = (lo_bit_count >> 8) & 0xFF
-    sha_info["data"][63] = (lo_bit_count >> 0) & 0xFF
-
-    sha_transform(sha_info)
-
-    dig = []
-    for i in sha_info["digest"]:
-        dig.extend([((i >> 24) & 0xFF), ((i >> 16) & 0xFF), ((i >> 8) & 0xFF), (i & 0xFF)])
-    return bytes(dig)
-
-
-class sha256(object):
-    digest_size = digestsize = SHA_DIGESTSIZE
-    block_size = SHA_BLOCKSIZE
-
-    def __init__(self, s=None):
-        self._sha = sha_init()
-        if s:
-            sha_update(self._sha, getbuf(s))
-
-    def update(self, s):
-        sha_update(self._sha, getbuf(s))
-
-    def digest(self):
-        return sha_final(self._sha.copy())[: self._sha["digestsize"]]
-
-    def hexdigest(self):
-        return "".join(["%.2x" % i for i in self.digest()])
-
-    def copy(self):
-        new = sha256()
-        new._sha = self._sha.copy()
-        return new
-
-
-class sha224(sha256):
-    digest_size = digestsize = 28
-
-    def __init__(self, s=None):
-        self._sha = sha224_init()
-        if s:
-            sha_update(self._sha, getbuf(s))
-
-    def copy(self):
-        new = sha224()
-        new._sha = self._sha.copy()
-        return new
-
-
-def test():
-    a_str = "just a test string"
-
-    assert (
-        b"\xe3\xb0\xc4B\x98\xfc\x1c\x14\x9a\xfb\xf4\xc8\x99o\xb9$'\xaeA\xe4d\x9b\x93L\xa4\x95\x99\x1bxR\xb8U"
-        == sha256().digest()
-    )
-    assert (
-        "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" == sha256().hexdigest()
-    )
-    assert (
-        "d7b553c6f09ac85d142415f857c5310f3bbbe7cdd787cce4b985acedd585266f"
-        == sha256(a_str).hexdigest()
-    )
-    assert (
-        "8113ebf33c97daa9998762aacafe750c7cefc2b2f173c90c59663a57fe626f21"
-        == sha256(a_str * 7).hexdigest()
-    )
-
-    s = sha256(a_str)
-    s.update(a_str)
-    assert "03d9963e05a094593190b6fc794cb1a3e1ac7d7883f0b5855268afeccc70d461" == s.hexdigest()
-
-
-if __name__ == "__main__":
-    test()

libs/micropython/hashlib/_sha384.py

@@ -1 +0,0 @@
-from ._sha512 import sha384

libs/micropython/hashlib/_sha512.py

@@ -1,519 +0,0 @@
-"""
-This code was Ported from CPython's sha512module.c
-"""
-
-SHA_BLOCKSIZE = 128
-SHA_DIGESTSIZE = 64
-
-
-def new_shaobject():
-    return {
-        "digest": [0] * 8,
-        "count_lo": 0,
-        "count_hi": 0,
-        "data": [0] * SHA_BLOCKSIZE,
-        "local": 0,
-        "digestsize": 0,
-    }
-
-
-ROR64 = (
-    lambda x, y: (((x & 0xFFFFFFFFFFFFFFFF) >> (y & 63)) | (x << (64 - (y & 63))))
-    & 0xFFFFFFFFFFFFFFFF
-)
-Ch = lambda x, y, z: (z ^ (x & (y ^ z)))
-Maj = lambda x, y, z: (((x | y) & z) | (x & y))
-S = lambda x, n: ROR64(x, n)
-R = lambda x, n: (x & 0xFFFFFFFFFFFFFFFF) >> n
-Sigma0 = lambda x: (S(x, 28) ^ S(x, 34) ^ S(x, 39))
-Sigma1 = lambda x: (S(x, 14) ^ S(x, 18) ^ S(x, 41))
-Gamma0 = lambda x: (S(x, 1) ^ S(x, 8) ^ R(x, 7))
-Gamma1 = lambda x: (S(x, 19) ^ S(x, 61) ^ R(x, 6))
-
-
-def sha_transform(sha_info):
-    W = []
-
-    d = sha_info["data"]
-    for i in range(0, 16):
-        W.append(
-            (d[8 * i] << 56)
-            + (d[8 * i + 1] << 48)
-            + (d[8 * i + 2] << 40)
-            + (d[8 * i + 3] << 32)
-            + (d[8 * i + 4] << 24)
-            + (d[8 * i + 5] << 16)
-            + (d[8 * i + 6] << 8)
-            + d[8 * i + 7]
-        )
-
-    for i in range(16, 80):
-        W.append(
-            (Gamma1(W[i - 2]) + W[i - 7] + Gamma0(W[i - 15]) + W[i - 16]) & 0xFFFFFFFFFFFFFFFF
-        )
-
-    ss = sha_info["digest"][:]
-
-    def RND(a, b, c, d, e, f, g, h, i, ki):
-        t0 = (h + Sigma1(e) + Ch(e, f, g) + ki + W[i]) & 0xFFFFFFFFFFFFFFFF
-        t1 = (Sigma0(a) + Maj(a, b, c)) & 0xFFFFFFFFFFFFFFFF
-        d = (d + t0) & 0xFFFFFFFFFFFFFFFF
-        h = (t0 + t1) & 0xFFFFFFFFFFFFFFFF
-        return d & 0xFFFFFFFFFFFFFFFF, h & 0xFFFFFFFFFFFFFFFF
-
-    ss[3], ss[7] = RND(
-        ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 0, 0x428A2F98D728AE22
-    )
-    ss[2], ss[6] = RND(
-        ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 1, 0x7137449123EF65CD
-    )
-    ss[1], ss[5] = RND(
-        ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 2, 0xB5C0FBCFEC4D3B2F
-    )
-    ss[0], ss[4] = RND(
-        ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 3, 0xE9B5DBA58189DBBC
-    )
-    ss[7], ss[3] = RND(
-        ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 4, 0x3956C25BF348B538
-    )
-    ss[6], ss[2] = RND(
-        ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 5, 0x59F111F1B605D019
-    )
-    ss[5], ss[1] = RND(
-        ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 6, 0x923F82A4AF194F9B
-    )
-    ss[4], ss[0] = RND(
-        ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 7, 0xAB1C5ED5DA6D8118
-    )
-    ss[3], ss[7] = RND(
-        ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 8, 0xD807AA98A3030242
-    )
-    ss[2], ss[6] = RND(
-        ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 9, 0x12835B0145706FBE
-    )
-    ss[1], ss[5] = RND(
-        ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 10, 0x243185BE4EE4B28C
-    )
-    ss[0], ss[4] = RND(
-        ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 11, 0x550C7DC3D5FFB4E2
-    )
-    ss[7], ss[3] = RND(
-        ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 12, 0x72BE5D74F27B896F
-    )
-    ss[6], ss[2] = RND(
-        ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 13, 0x80DEB1FE3B1696B1
-    )
-    ss[5], ss[1] = RND(
-        ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 14, 0x9BDC06A725C71235
-    )
-    ss[4], ss[0] = RND(
-        ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 15, 0xC19BF174CF692694
-    )
-    ss[3], ss[7] = RND(
-        ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 16, 0xE49B69C19EF14AD2
-    )
-    ss[2], ss[6] = RND(
-        ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 17, 0xEFBE4786384F25E3
-    )
-    ss[1], ss[5] = RND(
-        ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 18, 0x0FC19DC68B8CD5B5
-    )
-    ss[0], ss[4] = RND(
-        ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 19, 0x240CA1CC77AC9C65
-    )
-    ss[7], ss[3] = RND(
-        ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 20, 0x2DE92C6F592B0275
-    )
-    ss[6], ss[2] = RND(
-        ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 21, 0x4A7484AA6EA6E483
-    )
-    ss[5], ss[1] = RND(
-        ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 22, 0x5CB0A9DCBD41FBD4
-    )
-    ss[4], ss[0] = RND(
-        ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 23, 0x76F988DA831153B5
-    )
-    ss[3], ss[7] = RND(
-        ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 24, 0x983E5152EE66DFAB
-    )
-    ss[2], ss[6] = RND(
-        ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 25, 0xA831C66D2DB43210
-    )
-    ss[1], ss[5] = RND(
-        ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 26, 0xB00327C898FB213F
-    )
-    ss[0], ss[4] = RND(
-        ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 27, 0xBF597FC7BEEF0EE4
-    )
-    ss[7], ss[3] = RND(
-        ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 28, 0xC6E00BF33DA88FC2
-    )
-    ss[6], ss[2] = RND(
-        ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 29, 0xD5A79147930AA725
-    )
-    ss[5], ss[1] = RND(
-        ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 30, 0x06CA6351E003826F
-    )
-    ss[4], ss[0] = RND(
-        ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 31, 0x142929670A0E6E70
-    )
-    ss[3], ss[7] = RND(
-        ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 32, 0x27B70A8546D22FFC
-    )
-    ss[2], ss[6] = RND(
-        ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 33, 0x2E1B21385C26C926
-    )
-    ss[1], ss[5] = RND(
-        ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 34, 0x4D2C6DFC5AC42AED
-    )
-    ss[0], ss[4] = RND(
-        ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 35, 0x53380D139D95B3DF
-    )
-    ss[7], ss[3] = RND(
-        ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 36, 0x650A73548BAF63DE
-    )
-    ss[6], ss[2] = RND(
-        ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 37, 0x766A0ABB3C77B2A8
-    )
-    ss[5], ss[1] = RND(
-        ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 38, 0x81C2C92E47EDAEE6
-    )
-    ss[4], ss[0] = RND(
-        ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 39, 0x92722C851482353B
-    )
-    ss[3], ss[7] = RND(
-        ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 40, 0xA2BFE8A14CF10364
-    )
-    ss[2], ss[6] = RND(
-        ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 41, 0xA81A664BBC423001
-    )
-    ss[1], ss[5] = RND(
-        ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 42, 0xC24B8B70D0F89791
-    )
-    ss[0], ss[4] = RND(
-        ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 43, 0xC76C51A30654BE30
-    )
-    ss[7], ss[3] = RND(
-        ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 44, 0xD192E819D6EF5218
-    )
-    ss[6], ss[2] = RND(
-        ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 45, 0xD69906245565A910
-    )
-    ss[5], ss[1] = RND(
-        ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 46, 0xF40E35855771202A
-    )
-    ss[4], ss[0] = RND(
-        ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 47, 0x106AA07032BBD1B8
-    )
-    ss[3], ss[7] = RND(
-        ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 48, 0x19A4C116B8D2D0C8
-    )
-    ss[2], ss[6] = RND(
-        ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 49, 0x1E376C085141AB53
-    )
-    ss[1], ss[5] = RND(
-        ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 50, 0x2748774CDF8EEB99
-    )
-    ss[0], ss[4] = RND(
-        ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 51, 0x34B0BCB5E19B48A8
-    )
-    ss[7], ss[3] = RND(
-        ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 52, 0x391C0CB3C5C95A63
-    )
-    ss[6], ss[2] = RND(
-        ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 53, 0x4ED8AA4AE3418ACB
-    )
-    ss[5], ss[1] = RND(
-        ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 54, 0x5B9CCA4F7763E373
-    )
-    ss[4], ss[0] = RND(
-        ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 55, 0x682E6FF3D6B2B8A3
-    )
-    ss[3], ss[7] = RND(
-        ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 56, 0x748F82EE5DEFB2FC
-    )
-    ss[2], ss[6] = RND(
-        ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 57, 0x78A5636F43172F60
-    )
-    ss[1], ss[5] = RND(
-        ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 58, 0x84C87814A1F0AB72
-    )
-    ss[0], ss[4] = RND(
-        ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 59, 0x8CC702081A6439EC
-    )
-    ss[7], ss[3] = RND(
-        ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 60, 0x90BEFFFA23631E28
-    )
-    ss[6], ss[2] = RND(
-        ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 61, 0xA4506CEBDE82BDE9
-    )
-    ss[5], ss[1] = RND(
-        ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 62, 0xBEF9A3F7B2C67915
-    )
-    ss[4], ss[0] = RND(
-        ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 63, 0xC67178F2E372532B
-    )
-    ss[3], ss[7] = RND(
-        ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 64, 0xCA273ECEEA26619C
-    )
-    ss[2], ss[6] = RND(
-        ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 65, 0xD186B8C721C0C207
-    )
-    ss[1], ss[5] = RND(
-        ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 66, 0xEADA7DD6CDE0EB1E
-    )
-    ss[0], ss[4] = RND(
-        ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 67, 0xF57D4F7FEE6ED178
-    )
-    ss[7], ss[3] = RND(
-        ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 68, 0x06F067AA72176FBA
-    )
-    ss[6], ss[2] = RND(
-        ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 69, 0x0A637DC5A2C898A6
-    )
-    ss[5], ss[1] = RND(
-        ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 70, 0x113F9804BEF90DAE
-    )
-    ss[4], ss[0] = RND(
-        ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 71, 0x1B710B35131C471B
-    )
-    ss[3], ss[7] = RND(
-        ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], 72, 0x28DB77F523047D84
-    )
-    ss[2], ss[6] = RND(
-        ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], 73, 0x32CAAB7B40C72493
-    )
-    ss[1], ss[5] = RND(
-        ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], 74, 0x3C9EBE0A15C9BEBC
-    )
-    ss[0], ss[4] = RND(
-        ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], ss[4], 75, 0x431D67C49C100D4C
-    )
-    ss[7], ss[3] = RND(
-        ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], ss[3], 76, 0x4CC5D4BECB3E42B6
-    )
-    ss[6], ss[2] = RND(
-        ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], ss[2], 77, 0x597F299CFC657E2A
-    )
-    ss[5], ss[1] = RND(
-        ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], ss[1], 78, 0x5FCB6FAB3AD6FAEC
-    )
-    ss[4], ss[0] = RND(
-        ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[0], 79, 0x6C44198C4A475817
-    )
-
-    dig = []
-    for i, x in enumerate(sha_info["digest"]):
-        dig.append((x + ss[i]) & 0xFFFFFFFFFFFFFFFF)
-    sha_info["digest"] = dig
-
-
-def sha_init():
-    sha_info = new_shaobject()
-    sha_info["digest"] = [
-        0x6A09E667F3BCC908,
-        0xBB67AE8584CAA73B,
-        0x3C6EF372FE94F82B,
-        0xA54FF53A5F1D36F1,
-        0x510E527FADE682D1,
-        0x9B05688C2B3E6C1F,
-        0x1F83D9ABFB41BD6B,
-        0x5BE0CD19137E2179,
-    ]
-    sha_info["count_lo"] = 0
-    sha_info["count_hi"] = 0
-    sha_info["local"] = 0
-    sha_info["digestsize"] = 64
-    return sha_info
-
-
-def sha384_init():
-    sha_info = new_shaobject()
-    sha_info["digest"] = [
-        0xCBBB9D5DC1059ED8,
-        0x629A292A367CD507,
-        0x9159015A3070DD17,
-        0x152FECD8F70E5939,
-        0x67332667FFC00B31,
-        0x8EB44A8768581511,
-        0xDB0C2E0D64F98FA7,
-        0x47B5481DBEFA4FA4,
-    ]
-    sha_info["count_lo"] = 0
-    sha_info["count_hi"] = 0
-    sha_info["local"] = 0
-    sha_info["digestsize"] = 48
-    return sha_info
-
-
-def getbuf(s):
-    if isinstance(s, str):
-        return s.encode("ascii")
-    else:
-        return bytes(s)
-
-
-def sha_update(sha_info, buffer):
-    if isinstance(buffer, str):
-        raise TypeError("Unicode strings must be encoded before hashing")
-    count = len(buffer)
-    buffer_idx = 0
-    clo = (sha_info["count_lo"] + (count << 3)) & 0xFFFFFFFF
-    if clo < sha_info["count_lo"]:
-        sha_info["count_hi"] += 1
-    sha_info["count_lo"] = clo
-
-    sha_info["count_hi"] += count >> 29
-
-    if sha_info["local"]:
-        i = SHA_BLOCKSIZE - sha_info["local"]
-        if i > count:
-            i = count
-
-        # copy buffer
-        for x in enumerate(buffer[buffer_idx : buffer_idx + i]):
-            sha_info["data"][sha_info["local"] + x[0]] = x[1]
-
-        count -= i
-        buffer_idx += i
-
-        sha_info["local"] += i
-        if sha_info["local"] == SHA_BLOCKSIZE:
-            sha_transform(sha_info)
-            sha_info["local"] = 0
-        else:
-            return
-
-    while count >= SHA_BLOCKSIZE:
-        # copy buffer
-        sha_info["data"] = list(buffer[buffer_idx : buffer_idx + SHA_BLOCKSIZE])
-        count -= SHA_BLOCKSIZE
-        buffer_idx += SHA_BLOCKSIZE
-        sha_transform(sha_info)
-
-    # copy buffer
-    pos = sha_info["local"]
-    sha_info["data"][pos : pos + count] = list(buffer[buffer_idx : buffer_idx + count])
-    sha_info["local"] = count
-
-
-def sha_final(sha_info):
-    lo_bit_count = sha_info["count_lo"]
-    hi_bit_count = sha_info["count_hi"]
-    count = (lo_bit_count >> 3) & 0x7F
-    sha_info["data"][count] = 0x80
-    count += 1
-    if count > SHA_BLOCKSIZE - 16:
-        # zero the bytes in data after the count
-        sha_info["data"] = sha_info["data"][:count] + ([0] * (SHA_BLOCKSIZE - count))
-        sha_transform(sha_info)
-        # zero bytes in data
-        sha_info["data"] = [0] * SHA_BLOCKSIZE
-    else:
-        sha_info["data"] = sha_info["data"][:count] + ([0] * (SHA_BLOCKSIZE - count))
-
-    sha_info["data"][112] = 0
-    sha_info["data"][113] = 0
-    sha_info["data"][114] = 0
-    sha_info["data"][115] = 0
-    sha_info["data"][116] = 0
-    sha_info["data"][117] = 0
-    sha_info["data"][118] = 0
-    sha_info["data"][119] = 0
-
-    sha_info["data"][120] = (hi_bit_count >> 24) & 0xFF
-    sha_info["data"][121] = (hi_bit_count >> 16) & 0xFF
-    sha_info["data"][122] = (hi_bit_count >> 8) & 0xFF
-    sha_info["data"][123] = (hi_bit_count >> 0) & 0xFF
-    sha_info["data"][124] = (lo_bit_count >> 24) & 0xFF
-    sha_info["data"][125] = (lo_bit_count >> 16) & 0xFF
-    sha_info["data"][126] = (lo_bit_count >> 8) & 0xFF
-    sha_info["data"][127] = (lo_bit_count >> 0) & 0xFF
-
-    sha_transform(sha_info)
-
-    dig = []
-    for i in sha_info["digest"]:
-        dig.extend(
-            [
-                ((i >> 56) & 0xFF),
-                ((i >> 48) & 0xFF),
-                ((i >> 40) & 0xFF),
-                ((i >> 32) & 0xFF),
-                ((i >> 24) & 0xFF),
-                ((i >> 16) & 0xFF),
-                ((i >> 8) & 0xFF),
-                (i & 0xFF),
-            ]
-        )
-    return bytes(dig)
-
-
-class sha512(object):
-    digest_size = digestsize = SHA_DIGESTSIZE
-    block_size = SHA_BLOCKSIZE
-
-    def __init__(self, s=None):
-        self._sha = sha_init()
-        if s:
-            sha_update(self._sha, getbuf(s))
-
-    def update(self, s):
-        sha_update(self._sha, getbuf(s))
-
-    def digest(self):
-        return sha_final(self._sha.copy())[: self._sha["digestsize"]]
-
-    def hexdigest(self):
-        return "".join(["%.2x" % i for i in self.digest()])
-
-    def copy(self):
-        new = sha512()
-        new._sha = self._sha.copy()
-        return new
-
-
-class sha384(sha512):
-    digest_size = digestsize = 48
-
-    def __init__(self, s=None):
-        self._sha = sha384_init()
-        if s:
-            sha_update(self._sha, getbuf(s))
-
-    def copy(self):
-        new = sha384()
-        new._sha = self._sha.copy()
-        return new
-
-
-def test():
-    a_str = "just a test string"
-
-    assert (
-        sha512().digest()
-        == b"\xcf\x83\xe15~\xef\xb8\xbd\xf1T(P\xd6m\x80\x07\xd6 \xe4\x05\x0bW\x15\xdc\x83\xf4\xa9!\xd3l\xe9\xceG\xd0\xd1<]\x85\xf2\xb0\xff\x83\x18\xd2\x87~\xec/c\xb91\xbdGAz\x81\xa582z\xf9'\xda>"
-    )
-    assert (
-        sha512().hexdigest()
-        == "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e"
-    )
-    assert (
-        sha512(a_str).hexdigest()
-        == "68be4c6664af867dd1d01c8d77e963d87d77b702400c8fabae355a41b8927a5a5533a7f1c28509bbd65c5f3ac716f33be271fbda0ca018b71a84708c9fae8a53"
-    )
-    assert (
-        sha512(a_str * 7).hexdigest()
-        == "3233acdbfcfff9bff9fc72401d31dbffa62bd24e9ec846f0578d647da73258d9f0879f7fde01fe2cc6516af3f343807fdef79e23d696c923d79931db46bf1819"
-    )
-
-    s = sha512(a_str)
-    s.update(a_str)
-    assert (
-        s.hexdigest()
-        == "341aeb668730bbb48127d5531115f3c39d12cb9586a6ca770898398aff2411087cfe0b570689adf328cddeb1f00803acce6737a19f310b53bbdb0320828f75bb"
-    )
-
-
-if __name__ == "__main__":
-    test()

libs/micropython/hmac.py

@@ -1,152 +1,87 @@
-"""HMAC (Keyed-Hashing for Message Authentication) Python module.
-Implements the HMAC algorithm as described by RFC 2104.
-"""
-
-import warnings as _warnings
-
-# from _operator import _compare_digest as compare_digest
-import hashlib as _hashlib
-
-PendingDeprecationWarning = None
-RuntimeWarning = None
-
-trans_5C = bytes((x ^ 0x5C) for x in range(256))
-trans_36 = bytes((x ^ 0x36) for x in range(256))
-
-
-def translate(d, t):
-    return bytes(t[x] for x in d)
-
-
-# The size of the digests returned by HMAC depends on the underlying
-# hashing module used.  Use digest_size from the instance of HMAC instead.
-digest_size = None
+# Implements the hmac module from the Python standard library.
 
 
 class HMAC:
-    """RFC 2104 HMAC class.  Also complies with RFC 4231.
-    This supports the API for Cryptographic Hash Functions (PEP 247).
-    """
-
-    blocksize = 64  # 512-bit HMAC; can be changed in subclasses.
-
     def __init__(self, key, msg=None, digestmod=None):
-        """Create a new HMAC object.
-        key:       key for the keyed hash object.
-        msg:       Initial input for the hash, if provided.
-        digestmod: A module supporting PEP 247.  *OR*
-                   A hashlib constructor returning a new hash object. *OR*
-                   A hash name suitable for hashlib.new().
-                   Defaults to hashlib.md5.
-                   Implicit default to hashlib.md5 is deprecated and will be
-                   removed in Python 3.6.
-        Note: key and msg must be a bytes or bytearray objects.
-        """
-
         if not isinstance(key, (bytes, bytearray)):
-            raise TypeError("key: expected bytes or bytearray, but got %r" % type(key).__name__)
+            raise TypeError("key: expected bytes/bytearray")
+
+        import hashlib
 
         if digestmod is None:
-            _warnings.warn(
-                "HMAC() without an explicit digestmod argument " "is deprecated.",
-                PendingDeprecationWarning,
-                2,
-            )
-            digestmod = _hashlib.md5
+            # TODO: Default hash algorithm is now deprecated.
+            digestmod = hashlib.md5
 
         if callable(digestmod):
-            self.digest_cons = digestmod
+            # A hashlib constructor returning a new hash object.
+            make_hash = digestmod  # A
         elif isinstance(digestmod, str):
-            self.digest_cons = lambda d=b"": _hashlib.new(digestmod, d)
+            # A hash name suitable for hashlib.new().
+            make_hash = lambda d=b"": hashlib.new(digestmod, d)  # B
         else:
-            self.digest_cons = lambda d=b"": digestmod.new(d)
+            # A module supporting PEP 247.
+            make_hash = digestmod.new  # C
 
-        self.outer = self.digest_cons()
-        self.inner = self.digest_cons()
-        self.digest_size = self.inner.digest_size
+        self._outer = make_hash()
+        self._inner = make_hash()
 
-        if hasattr(self.inner, "block_size"):
-            blocksize = self.inner.block_size
-            if blocksize < 16:
-                _warnings.warn(
-                    "block_size of %d seems too small; using our "
-                    "default of %d." % (blocksize, self.blocksize),
-                    RuntimeWarning,
-                    2,
-                )
-                blocksize = self.blocksize
-        else:
-            _warnings.warn(
-                "No block_size attribute on given digest object; "
-                "Assuming %d." % (self.blocksize),
-                RuntimeWarning,
-                2,
-            )
-            blocksize = self.blocksize
+        self.digest_size = getattr(self._inner, "digest_size", None)
+        # If the provided hash doesn't support block_size (e.g. built-in
+        # hashlib), 64 is the correct default for all built-in hash
+        # functions (md5, sha1, sha256).
+        self.block_size = getattr(self._inner, "block_size", 64)
 
-        # self.blocksize is the default blocksize. self.block_size is
-        # effective block size as well as the public API attribute.
-        self.block_size = blocksize
+        # Truncate to digest_size if greater than block_size.
+        if len(key) > self.block_size:
+            key = make_hash(key).digest()
 
-        if len(key) > blocksize:
-            key = self.digest_cons(key).digest()
+        # Pad to block size.
+        key = key + bytes(self.block_size - len(key))
+
+        self._outer.update(bytes(x ^ 0x5C for x in key))
+        self._inner.update(bytes(x ^ 0x36 for x in key))
 
-        key = key + bytes(blocksize - len(key))
-        self.outer.update(translate(key, trans_5C))
-        self.inner.update(translate(key, trans_36))
         if msg is not None:
             self.update(msg)
 
     @property
     def name(self):
-        return "hmac-" + self.inner.name
+        return "hmac-" + getattr(self._inner, "name", type(self._inner).__name__)
 
     def update(self, msg):
-        """Update this hashing object with the string msg."""
-        self.inner.update(msg)
+        self._inner.update(msg)
 
     def copy(self):
-        """Return a separate copy of this hashing object.
-        An update to this copy won't affect the original object.
-        """
+        if not hasattr(self._inner, "copy"):
+            # Not supported for built-in hash functions.
+            raise NotImplementedError()
         # Call __new__ directly to avoid the expensive __init__.
         other = self.__class__.__new__(self.__class__)
-        other.digest_cons = self.digest_cons
+        other.block_size = self.block_size
         other.digest_size = self.digest_size
-        other.inner = self.inner.copy()
-        other.outer = self.outer.copy()
+        other._inner = self._inner.copy()
+        other._outer = self._outer.copy()
         return other
 
     def _current(self):
-        """Return a hash object for the current state.
-        To be used only internally with digest() and hexdigest().
-        """
-        h = self.outer.copy()
-        h.update(self.inner.digest())
+        h = self._outer
+        if hasattr(h, "copy"):
+            # built-in hash functions don't support this, and as a result,
+            # digest() will finalise the hmac and further calls to
+            # update/digest will fail.
+            h = h.copy()
+        h.update(self._inner.digest())
         return h
 
     def digest(self):
-        """Return the hash value of this hashing object.
-        This returns a string containing 8-bit data.  The object is
-        not altered in any way by this function; you can continue
-        updating the object after calling this function.
-        """
         h = self._current()
         return h.digest()
 
     def hexdigest(self):
-        """Like digest(), but returns a string of hexadecimal digits instead."""
-        h = self._current()
-        return h.hexdigest()
+        import binascii
+
+        return str(binascii.hexlify(self.digest()), "utf-8")
 
 
 def new(key, msg=None, digestmod=None):
-    """Create a new hashing object and return it.
-    key: The starting key for the hash.
-    msg: if available, will immediately be hashed into the object's starting
-    state.
-    You can now feed arbitrary strings into the object using its update()
-    method, and can ask for the hash value at any time by calling its digest()
-    method.
-    """
     return HMAC(key, msg, digestmod)

libs/micropython/jwt.py

@@ -4,7 +4,6 @@ import hmac
 import json
 from time import time
 
-
 def _to_b64url(data):
     return (
         binascii.b2a_base64(data)
@@ -32,13 +31,13 @@ class exceptions:
     class InvalidSignatureError(PyJWTError):
         pass
 
-    class ExpiredTokenError(PyJWTError):
+    class ExpiredSignatureError(PyJWTError):
         pass
 
 
 def encode(payload, key, algorithm="HS256"):
     if algorithm != "HS256":
-        raise exceptions.InvalidAlgorithmError()
+        raise exceptions.InvalidAlgorithmError
 
     if isinstance(key, str):
         key = key.encode()
@@ -50,30 +49,30 @@ def encode(payload, key, algorithm="HS256"):
 
 def decode(token, key, algorithms=["HS256"]):
     if "HS256" not in algorithms:
-        raise exceptions.InvalidAlgorithmError()
+        raise exceptions.InvalidAlgorithmError
 
     parts = token.encode().split(b".")
     if len(parts) != 3:
-        raise exceptions.InvalidTokenError()
+        raise exceptions.InvalidTokenError
 
     try:
         header = json.loads(_from_b64url(parts[0]).decode())
         payload = json.loads(_from_b64url(parts[1]).decode())
         signature = _from_b64url(parts[2])
     except Exception:
-        raise exceptions.InvalidTokenError()
+        raise exceptions.InvalidTokenError
 
     if header["alg"] not in algorithms or header["alg"] != "HS256":
-        raise exceptions.InvalidAlgorithmError()
+        raise exceptions.InvalidAlgorithmError
 
     if isinstance(key, str):
         key = key.encode()
     calculated_signature = hmac.new(key, parts[0] + b"." + parts[1], hashlib.sha256).digest()
     if signature != calculated_signature:
-        raise exceptions.InvalidSignatureError()
+        raise exceptions.InvalidSignatureError
 
     if "exp" in payload:
         if time() > payload["exp"]:
-            raise exceptions.ExpiredTokenError()
+            raise exceptions.ExpiredSignatureError
 
     return payload

libs/micropython/uasyncio/core.py

@@ -41,7 +41,7 @@ class SingletonGenerator:
 
     def __next__(self):
         if self.state is not None:
-            _task_queue.push_sorted(cur_task, self.state)
+            _task_queue.push(cur_task, self.state)
             self.state = None
             return None
         else:
@@ -115,11 +115,11 @@ class IOQueue:
             # print('poll', s, sm, ev)
             if ev & ~select.POLLOUT and sm[0] is not None:
                 # POLLIN or error
-                _task_queue.push_head(sm[0])
+                _task_queue.push(sm[0])
                 sm[0] = None
             if ev & ~select.POLLIN and sm[1] is not None:
                 # POLLOUT or error
-                _task_queue.push_head(sm[1])
+                _task_queue.push(sm[1])
                 sm[1] = None
             if sm[0] is None and sm[1] is None:
                 self._dequeue(s)
@@ -142,7 +142,7 @@ def create_task(coro):
     if not hasattr(coro, "send"):
         raise TypeError("coroutine expected")
     t = Task(coro, globals())
-    _task_queue.push_head(t)
+    _task_queue.push(t)
     return t
 
 
@@ -167,7 +167,7 @@ def run_until_complete(main_task=None):
             _io_queue.wait_io_event(dt)
 
         # Get next task to run and continue it
-        t = _task_queue.pop_head()
+        t = _task_queue.pop()
         cur_task = t
         try:
             # Continue running the coroutine, it's responsible for rescheduling itself
@@ -175,6 +175,10 @@ def run_until_complete(main_task=None):
             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:
@@ -185,22 +189,37 @@ def run_until_complete(main_task=None):
                 if isinstance(er, StopIteration):
                     return er.value
                 raise er
-            # Schedule any other tasks waiting on the completion of this task
-            waiting = False
-            if hasattr(t, "waiting"):
-                while t.waiting.peek():
-                    _task_queue.push_head(t.waiting.pop_head())
+            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
-                t.waiting = None  # Free waiting queue head
-            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)
-            # Indicate task is done by setting coro to the task object itself
-            t.coro = t
-            # Save return value of coro to pass up to caller
-            t.data = er
+                else:
+                    # Schedule any other tasks waiting on the completion of this task.
+                    while t.state.peek():
+                        _task_queue.push(t.state.pop())
+                        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(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
@@ -237,7 +256,7 @@ class Loop:
     def stop():
         global _stop_task
         if _stop_task is not None:
-            _task_queue.push_head(_stop_task)
+            _task_queue.push(_stop_task)
             # If stop() is called again, do nothing
             _stop_task = None
 

libs/micropython/uasyncio/event.py

@@ -17,7 +17,7 @@ class Event:
         # 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())
+            core._task_queue.push(self.waiting.pop())
         self.state = True
 
     def clear(self):
@@ -26,7 +26,7 @@ class Event:
     async def wait(self):
         if not self.state:
             # Event not set, put the calling task on the event's waiting queue
-            self.waiting.push_head(core.cur_task)
+            self.waiting.push(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
             yield
@@ -36,27 +36,29 @@ class Event:
 # 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.
+# Note: Unlike Event, this is self-clearing after a wait().
 try:
     import uio
 
     class ThreadSafeFlag(uio.IOBase):
         def __init__(self):
-            self._flag = 0
+            self.state = 0
 
         def ioctl(self, req, flags):
             if req == 3:  # MP_STREAM_POLL
-                return self._flag * flags
+                return self.state * flags
             return None
 
         def set(self):
-            self._flag = 1
+            self.state = 1
+
+        def clear(self):
+            self.state = 0
 
         async def wait(self):
-            if not self._flag:
+            if not self.state:
                 yield core._io_queue.queue_read(self)
-            self._flag = 0
-
+            self.state = 0
 
 except ImportError:
     pass

libs/micropython/uasyncio/funcs.py

@@ -1,49 +1,51 @@
 # MicroPython uasyncio module
-# MIT license; Copyright (c) 2019-2020 Damien P. George
+# MIT license; Copyright (c) 2019-2022 Damien P. George
 
 from . import core
 
 
+def _run(waiter, aw):
+    try:
+        result = await aw
+        status = True
+    except BaseException as er:
+        result = None
+        status = er
+    if waiter.data is None:
+        # The waiter is still waiting, cancel it.
+        if waiter.cancel():
+            # Waiter was cancelled by us, change its CancelledError to an instance of
+            # CancelledError that contains the status and result of waiting on aw.
+            # If the wait_for task subsequently gets cancelled externally then this
+            # instance will be reset to a CancelledError instance without arguments.
+            waiter.data = core.CancelledError(status, result)
+
+
 async def wait_for(aw, timeout, sleep=core.sleep):
     aw = core._promote_to_task(aw)
     if timeout is None:
         return await aw
 
-    def runner(waiter, aw):
-        nonlocal status, result
-        try:
-            result = await aw
-            s = True
-        except BaseException as er:
-            s = er
-        if status is None:
-            # The waiter is still waiting, set status for it and cancel it.
-            status = s
-            waiter.cancel()
-
     # Run aw in a separate runner task that manages its exceptions.
-    status = None
-    result = None
-    runner_task = core.create_task(runner(core.cur_task, aw))
+    runner_task = core.create_task(_run(core.cur_task, aw))
 
     try:
         # Wait for the timeout to elapse.
         await sleep(timeout)
     except core.CancelledError as er:
-        if status is True:
-            # aw completed successfully and cancelled the sleep, so return aw's result.
-            return result
-        elif status is None:
+        status = er.value
+        if status is None:
             # This wait_for was cancelled externally, so cancel aw and re-raise.
-            status = True
             runner_task.cancel()
             raise er
+        elif status is True:
+            # aw completed successfully and cancelled the sleep, so return aw's result.
+            return er.args[1]
         else:
             # aw raised an exception, propagate it out to the caller.
             raise status
 
     # The sleep finished before aw, so cancel aw and raise TimeoutError.
-    status = True
     runner_task.cancel()
     await runner_task
     raise core.TimeoutError
@@ -53,22 +55,75 @@ def wait_for_ms(aw, timeout):
     return wait_for(aw, timeout, core.sleep_ms)
 
 
+class _Remove:
+    @staticmethod
+    def remove(t):
+        pass
+
+
 async def gather(*aws, return_exceptions=False):
+    if not aws:
+        return []
+
+    def done(t, er):
+        # Sub-task "t" has finished, with exception "er".
+        nonlocal state
+        if gather_task.data is not _Remove:
+            # The main gather task has already been scheduled, so do nothing.
+            # This happens if another sub-task already raised an exception and
+            # woke the main gather task (via this done function), or if the main
+            # gather task was cancelled externally.
+            return
+        elif not return_exceptions and not isinstance(er, StopIteration):
+            # A sub-task raised an exception, indicate that to the gather task.
+            state = er
+        else:
+            state -= 1
+            if state:
+                # Still some sub-tasks running.
+                return
+        # Gather waiting is done, schedule the main gather task.
+        core._task_queue.push(gather_task)
+
     ts = [core._promote_to_task(aw) for aw in aws]
     for i in range(len(ts)):
-        try:
-            # TODO handle cancel of gather itself
-            # if ts[i].coro:
-            #    iter(ts[i]).waiting.push_head(cur_task)
-            #    try:
-            #        yield
-            #    except CancelledError as er:
-            #        # cancel all waiting tasks
-            #        raise er
-            ts[i] = await ts[i]
-        except Exception as er:
-            if return_exceptions:
-                ts[i] = er
-            else:
-                raise er
+        if ts[i].state is not True:
+            # Task is not running, gather not currently supported for this case.
+            raise RuntimeError("can't gather")
+        # Register the callback to call when the task is done.
+        ts[i].state = done
+
+    # Set the state for execution of the gather.
+    gather_task = core.cur_task
+    state = len(ts)
+    cancel_all = False
+
+    # Wait for the a sub-task to need attention.
+    gather_task.data = _Remove
+    try:
+        yield
+    except core.CancelledError as er:
+        cancel_all = True
+        state = er
+
+    # Clean up tasks.
+    for i in range(len(ts)):
+        if ts[i].state is done:
+            # Sub-task is still running, deregister the callback and cancel if needed.
+            ts[i].state = True
+            if cancel_all:
+                ts[i].cancel()
+        elif isinstance(ts[i].data, StopIteration):
+            # Sub-task ran to completion, get its return value.
+            ts[i] = ts[i].data.value
+        else:
+            # Sub-task had an exception with return_exceptions==True, so get its exception.
+            ts[i] = ts[i].data
+
+    # Either this gather was cancelled, or one of the sub-tasks raised an exception with
+    # return_exceptions==False, so reraise the exception here.
+    if state is not 0:
+        raise state
+
+    # Return the list of return values of each sub-task.
     return ts

libs/micropython/uasyncio/lock.py

@@ -22,8 +22,8 @@ class Lock:
             raise RuntimeError("Lock not acquired")
         if self.waiting.peek():
             # Task(s) waiting on lock, schedule next Task
-            self.state = self.waiting.pop_head()
-            core._task_queue.push_head(self.state)
+            self.state = self.waiting.pop()
+            core._task_queue.push(self.state)
         else:
             # No Task waiting so unlock
             self.state = 0
@@ -31,7 +31,7 @@ class Lock:
     async def acquire(self):
         if self.state != 0:
             # Lock unavailable, put the calling Task on the waiting queue
-            self.waiting.push_head(core.cur_task)
+            self.waiting.push(core.cur_task)
             # Set calling task's data to the lock's queue so it can be removed if needed
             core.cur_task.data = self.waiting
             try:

libs/micropython/uasyncio/manifest.py

@@ -1,13 +1,15 @@
-# This list of frozen files doesn't include task.py because that's provided by the C module.
-freeze(
-    "..",
+# This list of package files doesn't include task.py because that's provided
+# by the C module.
+package(
+    "uasyncio",
     (
-        "uasyncio/__init__.py",
-        "uasyncio/core.py",
-        "uasyncio/event.py",
-        "uasyncio/funcs.py",
-        "uasyncio/lock.py",
-        "uasyncio/stream.py",
+        "__init__.py",
+        "core.py",
+        "event.py",
+        "funcs.py",
+        "lock.py",
+        "stream.py",
     ),
+    base_path="..",
     opt=3,
 )

libs/micropython/uasyncio/stream.py

@@ -26,9 +26,21 @@ class Stream:
         # TODO yield?
         self.s.close()
 
-    async def read(self, n):
+    async def read(self, n=-1):
+        r = b""
+        while True:
+            yield core._io_queue.queue_read(self.s)
+            r2 = self.s.read(n)
+            if r2 is not None:
+                if n >= 0:
+                    return r2
+                if not len(r2):
+                    return r
+                r += r2
+
+    async def readinto(self, buf):
         yield core._io_queue.queue_read(self.s)
-        return self.s.read(n)
+        return self.s.readinto(buf)
 
     async def readexactly(self, n):
         r = b""
@@ -52,9 +64,19 @@ class Stream:
                 return l
 
     def write(self, buf):
+        if not self.out_buf:
+            # Try to write immediately to the underlying stream.
+            ret = self.s.write(buf)
+            if ret == len(buf):
+                return
+            if ret is not None:
+                buf = buf[ret:]
         self.out_buf += buf
 
     async def drain(self):
+        if not self.out_buf:
+            # Drain must always yield, so a tight loop of write+drain can't block the scheduler.
+            return await core.sleep_ms(0)
         mv = memoryview(self.out_buf)
         off = 0
         while off < len(mv):
@@ -75,8 +97,8 @@ async def open_connection(host, port):
     from uerrno import EINPROGRESS
     import usocket as socket
 
-    ai = socket.getaddrinfo(host, port)[0]  # TODO this is blocking!
-    s = socket.socket()
+    ai = socket.getaddrinfo(host, port, 0, socket.SOCK_STREAM)[0]  # TODO this is blocking!
+    s = socket.socket(ai[0], ai[1], ai[2])
     s.setblocking(False)
     ss = Stream(s)
     try:
@@ -103,16 +125,7 @@ class Server:
     async def wait_closed(self):
         await self.task
 
-    async def _serve(self, cb, host, port, backlog):
-        import usocket as socket
-
-        ai = socket.getaddrinfo(host, port)[0]  # TODO this is blocking!
-        s = socket.socket()
-        s.setblocking(False)
-        s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-        s.bind(ai[-1])
-        s.listen(backlog)
-        self.task = core.cur_task
+    async def _serve(self, s, cb):
         # Accept incoming connections
         while True:
             try:
@@ -134,9 +147,20 @@ class Server:
 # Helper function to start a TCP stream server, running as a new task
 # TODO could use an accept-callback on socket read activity instead of creating a task
 async def start_server(cb, host, port, backlog=5):
-    s = Server()
-    core.create_task(s._serve(cb, host, port, backlog))
-    return s
+    import usocket as socket
+
+    # Create and bind server socket.
+    host = socket.getaddrinfo(host, port)[0]  # TODO this is blocking!
+    s = socket.socket()
+    s.setblocking(False)
+    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    s.bind(host[-1])
+    s.listen(backlog)
+
+    # Create and return server object and task.
+    srv = Server()
+    srv.task = core.create_task(srv._serve(s, cb))
+    return srv
 
 
 ################################################################################

libs/micropython/uasyncio/task.py

@@ -99,19 +99,18 @@ class TaskQueue:
     def peek(self):
         return self.heap
 
-    def push_sorted(self, v, key):
+    def push(self, v, key=None):
+        assert v.ph_child is None
+        assert v.ph_next is None
         v.data = None
-        v.ph_key = key
-        v.ph_child = None
-        v.ph_next = None
+        v.ph_key = key if key is not None else core.ticks()
         self.heap = ph_meld(v, self.heap)
 
-    def push_head(self, v):
-        self.push_sorted(v, core.ticks())
-
-    def pop_head(self):
+    def pop(self):
         v = self.heap
-        self.heap = ph_pairing(self.heap.ph_child)
+        assert v.ph_next is None
+        self.heap = ph_pairing(v.ph_child)
+        v.ph_child = None
         return v
 
     def remove(self, v):
@@ -123,6 +122,7 @@ class Task:
     def __init__(self, coro, globals=None):
         self.coro = coro  # Coroutine of this Task
         self.data = None  # General data for queue it is waiting on
+        self.state = True  # None, False, True, a callable, or a TaskQueue instance
         self.ph_key = 0  # Pairing heap
         self.ph_child = None  # Paring heap
         self.ph_child_last = None  # Paring heap
@@ -130,30 +130,33 @@ class Task:
         self.ph_rightmost_parent = None  # Paring heap
 
     def __iter__(self):
-        if self.coro is self:
-            # Signal that the completed-task has been await'ed on.
-            self.waiting = None
-        elif not hasattr(self, "waiting"):
-            # Lazily allocated head of linked list of Tasks waiting on completion of this task.
-            self.waiting = TaskQueue()
+        if not self.state:
+            # Task finished, signal that is has been await'ed on.
+            self.state = False
+        elif self.state is True:
+            # Allocated head of linked list of Tasks waiting on completion of this task.
+            self.state = TaskQueue()
+        elif type(self.state) is not TaskQueue:
+            # Task has state used for another purpose, so can't also wait on it.
+            raise RuntimeError("can't wait")
         return self
 
     def __next__(self):
-        if self.coro is self:
+        if not self.state:
             # Task finished, raise return value to caller so it can continue.
             raise self.data
         else:
             # Put calling task on waiting queue.
-            self.waiting.push_head(core.cur_task)
+            self.state.push(core.cur_task)
             # Set calling task's data to this task that it waits on, to double-link it.
             core.cur_task.data = self
 
     def done(self):
-        return self.coro is self
+        return not self.state
 
     def cancel(self):
         # Check if task is already finished.
-        if self.coro is self:
+        if not self.state:
             return False
         # Can't cancel self (not supported yet).
         if self is core.cur_task:
@@ -165,20 +168,10 @@ class Task:
         if hasattr(self.data, "remove"):
             # Not on the main running queue, remove the task from the queue it's on.
             self.data.remove(self)
-            core._task_queue.push_head(self)
+            core._task_queue.push(self)
         elif core.ticks_diff(self.ph_key, core.ticks()) > 0:
             # On the main running queue but scheduled in the future, so bring it forward to now.
             core._task_queue.remove(self)
-            core._task_queue.push_head(self)
+            core._task_queue.push(self)
         self.data = core.CancelledError
         return True
-
-    def throw(self, value):
-        # This task raised an exception which was uncaught; handle that now.
-        # Set the data because it was cleared by the main scheduling loop.
-        self.data = value
-        if not hasattr(self, "waiting"):
-            # Nothing await'ed on the task so call the exception handler.
-            core._exc_context["exception"] = value
-            core._exc_context["future"] = self
-            core.Loop.call_exception_handler(core._exc_context)

libs/micropython/unittest.py

@@ -1,12 +1,18 @@
+import io
+import os
 import sys
 
+try:
+    import traceback
+except ImportError:
+    traceback = None
+
 
 class SkipTest(Exception):
     pass
 
 
 class AssertRaisesContext:
-
     def __init__(self, exc):
         self.expected = exc
 
@@ -14,29 +20,98 @@ class AssertRaisesContext:
         return self
 
     def __exit__(self, exc_type, exc_value, tb):
+        self.exception = exc_value
         if exc_type is None:
             assert False, "%r not raised" % self.expected
         if issubclass(exc_type, self.expected):
+            # store exception for later retrieval
+            self.exception = exc_value
             return True
         return False
 
 
-class TestCase:
+# These are used to provide required context to things like subTest
+__current_test__ = None
+__test_result__ = None
 
-    def fail(self, msg=''):
+
+class SubtestContext:
+    def __init__(self, msg=None, params=None):
+        self.msg = msg
+        self.params = params
+
+    def __enter__(self):
+        pass
+
+    def __exit__(self, *exc_info):
+        if exc_info[0] is not None:
+            # Exception raised
+            global __test_result__, __current_test__
+            test_details = __current_test__
+            if self.msg:
+                test_details += (f" [{self.msg}]",)
+            if self.params:
+                detail = ", ".join(f"{k}={v}" for k, v in self.params.items())
+                test_details += (f" ({detail})",)
+
+            _handle_test_exception(test_details, __test_result__, exc_info, False)
+        # Suppress the exception as we've captured it above
+        return True
+
+
+class NullContext:
+    def __enter__(self):
+        pass
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        pass
+
+
+class TestCase:
+    def __init__(self):
+        pass
+
+    def addCleanup(self, func, *args, **kwargs):
+        if not hasattr(self, "_cleanups"):
+            self._cleanups = []
+        self._cleanups.append((func, args, kwargs))
+
+    def doCleanups(self):
+        if hasattr(self, "_cleanups"):
+            while self._cleanups:
+                func, args, kwargs = self._cleanups.pop()
+                func(*args, **kwargs)
+
+    def subTest(self, msg=None, **params):
+        return SubtestContext(msg=msg, params=params)
+
+    def skipTest(self, reason):
+        raise SkipTest(reason)
+
+    def fail(self, msg=""):
         assert False, msg
 
-    def assertEqual(self, x, y, msg=''):
+    def assertEqual(self, x, y, msg=""):
         if not msg:
             msg = "%r vs (expected) %r" % (x, y)
         assert x == y, msg
 
-    def assertNotEqual(self, x, y, msg=''):
+    def assertNotEqual(self, x, y, msg=""):
         if not msg:
             msg = "%r not expected to be equal %r" % (x, y)
         assert x != y, msg
 
-    def assertAlmostEqual(self, x, y, places=None, msg='', delta=None):
+    def assertLessEqual(self, x, y, msg=None):
+        if msg is None:
+            msg = "%r is expected to be <= %r" % (x, y)
+        assert x <= y, msg
+
+    def assertGreaterEqual(self, x, y, msg=None):
+        if msg is None:
+            msg = "%r is expected to be >= %r" % (x, y)
+        assert x >= y, msg
+
+    def assertAlmostEqual(self, x, y, places=None, msg="", delta=None):
         if x == y:
             return
         if delta is not None and places is not None:
@@ -46,18 +121,18 @@ class TestCase:
             if abs(x - y) <= delta:
                 return
             if not msg:
-                msg = '%r != %r within %r delta' % (x, y, delta)
+                msg = "%r != %r within %r delta" % (x, y, delta)
         else:
             if places is None:
                 places = 7
-            if round(abs(y-x), places) == 0:
+            if round(abs(y - x), places) == 0:
                 return
             if not msg:
-                msg = '%r != %r within %r places' % (x, y, places)
+                msg = "%r != %r within %r places" % (x, y, places)
 
         assert False, msg
 
-    def assertNotAlmostEqual(self, x, y, places=None, msg='', delta=None):
+    def assertNotAlmostEqual(self, x, y, places=None, msg="", delta=None):
         if delta is not None and places is not None:
             raise TypeError("specify delta or places not both")
 
@@ -65,53 +140,53 @@ class TestCase:
             if not (x == y) and abs(x - y) > delta:
                 return
             if not msg:
-                msg = '%r == %r within %r delta' % (x, y, delta)
+                msg = "%r == %r within %r delta" % (x, y, delta)
         else:
             if places is None:
                 places = 7
-            if not (x == y) and round(abs(y-x), places) != 0:
+            if not (x == y) and round(abs(y - x), places) != 0:
                 return
             if not msg:
-                msg = '%r == %r within %r places' % (x, y, places)
+                msg = "%r == %r within %r places" % (x, y, places)
 
         assert False, msg
 
-    def assertIs(self, x, y, msg=''):
+    def assertIs(self, x, y, msg=""):
         if not msg:
             msg = "%r is not %r" % (x, y)
         assert x is y, msg
 
-    def assertIsNot(self, x, y, msg=''):
+    def assertIsNot(self, x, y, msg=""):
         if not msg:
             msg = "%r is %r" % (x, y)
         assert x is not y, msg
 
-    def assertIsNone(self, x, msg=''):
+    def assertIsNone(self, x, msg=""):
         if not msg:
             msg = "%r is not None" % x
         assert x is None, msg
 
-    def assertIsNotNone(self, x, msg=''):
+    def assertIsNotNone(self, x, msg=""):
         if not msg:
             msg = "%r is None" % x
         assert x is not None, msg
 
-    def assertTrue(self, x, msg=''):
+    def assertTrue(self, x, msg=""):
         if not msg:
             msg = "Expected %r to be True" % x
         assert x, msg
 
-    def assertFalse(self, x, msg=''):
+    def assertFalse(self, x, msg=""):
         if not msg:
             msg = "Expected %r to be False" % x
         assert not x, msg
 
-    def assertIn(self, x, y, msg=''):
+    def assertIn(self, x, y, msg=""):
         if not msg:
             msg = "Expected %r to be in %r" % (x, y)
         assert x in y, msg
 
-    def assertIsInstance(self, x, y, msg=''):
+    def assertIsInstance(self, x, y, msg=""):
         assert isinstance(x, y), msg
 
     def assertRaises(self, exc, func=None, *args, **kwargs):
@@ -120,12 +195,15 @@ class TestCase:
 
         try:
             func(*args, **kwargs)
-            assert False, "%r not raised" % exc
         except Exception as e:
             if isinstance(e, exc):
                 return
             raise
 
+        assert False, "%r not raised" % exc
+
+    def assertWarns(self, warn):
+        return NullContext()
 
 
 def skip(msg):
@@ -133,92 +211,252 @@ def skip(msg):
         # We just replace original fun with _inner
         def _inner(self):
             raise SkipTest(msg)
+
         return _inner
+
     return _decor
 
+
 def skipIf(cond, msg):
     if not cond:
         return lambda x: x
     return skip(msg)
 
+
 def skipUnless(cond, msg):
     if cond:
         return lambda x: x
     return skip(msg)
 
 
+def expectedFailure(test):
+    def test_exp_fail(*args, **kwargs):
+        try:
+            test(*args, **kwargs)
+        except:
+            pass
+        else:
+            assert False, "unexpected success"
+
+    return test_exp_fail
+
+
 class TestSuite:
-    def __init__(self):
-        self.tests = []
+    def __init__(self, name=""):
+        self._tests = []
+        self.name = name
+
     def addTest(self, cls):
-        self.tests.append(cls)
+        self._tests.append(cls)
+
+    def run(self, result):
+        for c in self._tests:
+            _run_suite(c, result, self.name)
+        return result
+
+    def _load_module(self, mod):
+        for tn in dir(mod):
+            c = getattr(mod, tn)
+            if isinstance(c, object) and isinstance(c, type) and issubclass(c, TestCase):
+                self.addTest(c)
+            elif tn.startswith("test") and callable(c):
+                self.addTest(c)
+
 
 class TestRunner:
-    def run(self, suite):
+    def run(self, suite: TestSuite):
         res = TestResult()
-        for c in suite.tests:
-            run_class(c, res)
+        suite.run(res)
 
+        res.printErrors()
+        print("----------------------------------------------------------------------")
         print("Ran %d tests\n" % res.testsRun)
         if res.failuresNum > 0 or res.errorsNum > 0:
             print("FAILED (failures=%d, errors=%d)" % (res.failuresNum, res.errorsNum))
         else:
             msg = "OK"
             if res.skippedNum > 0:
-                msg += " (%d skipped)" % res.skippedNum
+                msg += " (skipped=%d)" % res.skippedNum
             print(msg)
 
         return res
 
+
+TextTestRunner = TestRunner
+
+
 class TestResult:
     def __init__(self):
         self.errorsNum = 0
         self.failuresNum = 0
         self.skippedNum = 0
         self.testsRun = 0
+        self.errors = []
+        self.failures = []
+        self.skipped = []
+        self._newFailures = 0
 
     def wasSuccessful(self):
         return self.errorsNum == 0 and self.failuresNum == 0
 
-# TODO: Uncompliant
-def run_class(c, test_result):
-    o = c()
+    def printErrors(self):
+        print()
+        self.printErrorList(self.errors)
+        self.printErrorList(self.failures)
+
+    def printErrorList(self, lst):
+        sep = "----------------------------------------------------------------------"
+        for c, e in lst:
+            detail = " ".join((str(i) for i in c))
+            print("======================================================================")
+            print(f"FAIL: {detail}")
+            print(sep)
+            print(e)
+
+    def __repr__(self):
+        # Format is compatible with CPython.
+        return "<unittest.result.TestResult run=%d errors=%d failures=%d>" % (
+            self.testsRun,
+            self.errorsNum,
+            self.failuresNum,
+        )
+
+    def __add__(self, other):
+        self.errorsNum += other.errorsNum
+        self.failuresNum += other.failuresNum
+        self.skippedNum += other.skippedNum
+        self.testsRun += other.testsRun
+        self.errors.extend(other.errors)
+        self.failures.extend(other.failures)
+        self.skipped.extend(other.skipped)
+        return self
+
+
+def _capture_exc(exc, exc_traceback):
+    buf = io.StringIO()
+    if hasattr(sys, "print_exception"):
+        sys.print_exception(exc, buf)
+    elif traceback is not None:
+        traceback.print_exception(None, exc, exc_traceback, file=buf)
+    return buf.getvalue()
+
+
+def _handle_test_exception(
+    current_test: tuple, test_result: TestResult, exc_info: tuple, verbose=True
+):
+    exc = exc_info[1]
+    traceback = exc_info[2]
+    ex_str = _capture_exc(exc, traceback)
+    if isinstance(exc, AssertionError):
+        test_result.failuresNum += 1
+        test_result.failures.append((current_test, ex_str))
+        if verbose:
+            print(" FAIL")
+    else:
+        test_result.errorsNum += 1
+        test_result.errors.append((current_test, ex_str))
+        if verbose:
+            print(" ERROR")
+    test_result._newFailures += 1
+
+
+def _run_suite(c, test_result: TestResult, suite_name=""):
+    if isinstance(c, TestSuite):
+        c.run(test_result)
+        return
+
+    if isinstance(c, type):
+        o = c()
+    else:
+        o = c
+    set_up_class = getattr(o, "setUpClass", lambda: None)
+    tear_down_class = getattr(o, "tearDownClass", lambda: None)
     set_up = getattr(o, "setUp", lambda: None)
     tear_down = getattr(o, "tearDown", lambda: None)
-    for name in dir(o):
-        if name.startswith("test"):
-            print("%s (%s) ..." % (name, c.__qualname__), end="")
-            m = getattr(o, name)
-            set_up()
-            try:
-                test_result.testsRun += 1
-                m()
-                print(" ok")
-            except SkipTest as e:
-                print(" skipped:", e.args[0])
-                test_result.skippedNum += 1
-            except:
+    exceptions = []
+    try:
+        suite_name += "." + c.__qualname__
+    except AttributeError:
+        pass
+
+    def run_one(test_function):
+        global __test_result__, __current_test__
+        print("%s (%s) ..." % (name, suite_name), end="")
+        set_up()
+        __test_result__ = test_result
+        test_container = f"({suite_name})"
+        __current_test__ = (name, test_container)
+        try:
+            test_result._newFailures = 0
+            test_result.testsRun += 1
+            test_function()
+            # No exception occurred, test passed
+            if test_result._newFailures:
                 print(" FAIL")
-                test_result.failuresNum += 1
-                # Uncomment to investigate failure in detail
-                #raise
-                continue
-            finally:
-                tear_down()
+            else:
+                print(" ok")
+        except SkipTest as e:
+            reason = e.args[0]
+            print(" skipped:", reason)
+            test_result.skippedNum += 1
+            test_result.skipped.append((name, c, reason))
+        except Exception as ex:
+            _handle_test_exception(
+                current_test=(name, c), test_result=test_result, exc_info=(type(ex), ex, None)
+            )
+            # Uncomment to investigate failure in detail
+            # raise
+        finally:
+            __test_result__ = None
+            __current_test__ = None
+            tear_down()
+            try:
+                o.doCleanups()
+            except AttributeError:
+                pass
+
+    set_up_class()
+    try:
+        if hasattr(o, "runTest"):
+            name = str(o)
+            run_one(o.runTest)
+            return
+
+        for name in dir(o):
+            if name.startswith("test"):
+                m = getattr(o, name)
+                if not callable(m):
+                    continue
+                run_one(m)
+
+        if callable(o):
+            name = o.__name__
+            run_one(o)
+    finally:
+        tear_down_class()
+
+    return exceptions
 
 
-def main(module="__main__"):
-    def test_cases(m):
-        for tn in dir(m):
-            c = getattr(m, tn)
-            if isinstance(c, object) and isinstance(c, type) and issubclass(c, TestCase):
-                yield c
+# This supports either:
+#
+# >>> import mytest
+# >>> unitttest.main(mytest)
+#
+# >>> unittest.main("mytest")
+#
+# Or, a script that ends with:
+# if __name__ == "__main__":
+#     unittest.main()
+# e.g. run via `mpremote run mytest.py`
+def main(module="__main__", testRunner=None):
+    if testRunner is None:
+        testRunner = TestRunner()
+    elif isinstance(testRunner, type):
+        testRunner = testRunner()
 
-    m = __import__(module)
-    suite = TestSuite()
-    for c in test_cases(m):
-        suite.addTest(c)
-    runner = TestRunner()
-    result = runner.run(suite)
-    # Terminate with non zero return code in case of failures
-    sys.exit(result.failuresNum > 0)
+    if isinstance(module, str):
+        module = __import__(module)
+    suite = TestSuite(module.__name__)
+    suite._load_module(module)
+    return testRunner.run(suite)

libs/micropython/warnings.py

@@ -1,2 +0,0 @@
-def warn(msg, cat=None, stacklevel=1):
-    print("%s: %s" % ("Warning" if cat is None else cat.__name__, msg))

pyproject.toml

@@ -1,6 +1,57 @@
+[project]
+name = "microdot"
+version = "1.3.5.dev0"
+authors = [
+    { name = "Miguel Grinberg", email = "miguel.grinberg@gmail.com" },
+]
+description = "The impossibly small web framework for MicroPython"
+classifiers = [
+    "Environment :: Web Environment",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: Implementation :: MicroPython",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.readme]
+file = "README.md"
+content-type = "text/markdown"
+
+[project.urls]
+Homepage = "https://github.com/miguelgrinberg/microdot"
+"Bug Tracker" = "https://github.com/miguelgrinberg/microdot/issues"
+
+[project.optional-dependencies]
+docs = [
+    "sphinx",
+]
+
+[tool.setuptools]
+zip-safe = false
+include-package-data = true
+py-modules = [
+    "microdot",
+    "microdot_asyncio",
+    "microdot_utemplate",
+    "microdot_jinja",
+    "microdot_session",
+    "microdot_cors",
+    "microdot_websocket",
+    "microdot_websocket_alt",
+    "microdot_asyncio_websocket",
+    "microdot_test_client",
+    "microdot_asyncio_test_client",
+    "microdot_wsgi",
+    "microdot_asgi",
+    "microdot_asgi_websocket",
+]
+
+[tool.setuptools.package-dir]
+"" = "src"
+
 [build-system]
 requires = [
-    "setuptools>=42",
-    "wheel"
+    "setuptools>=61.2",
 ]
 build-backend = "setuptools.build_meta"

run_tests.py

@@ -6,4 +6,5 @@ sys.path.insert(3, 'libs/micropython')
 
 import unittest
 
-unittest.main('tests')
+if not unittest.main('tests').wasSuccessful():
+    sys.exit(1)

setup.cfg

@@ -1,34 +0,0 @@
-[metadata]
-name = microdot
-version = 1.0.0
-author = Miguel Grinberg
-author_email = miguel.grinberg@gmail.com
-description = The impossibly small web framework for MicroPython
-long_description = file: README.md
-long_description_content_type = text/markdown
-url = https://github.com/miguelgrinberg/microdot
-project_urls =
-    Bug Tracker = https://github.com/miguelgrinberg/microdot/issues
-classifiers =
-    Environment :: Web Environment
-    Intended Audience :: Developers
-    Programming Language :: Python :: 3
-    Programming Language :: Python :: Implementation :: MicroPython
-    License :: OSI Approved :: MIT License
-    Operating System :: OS Independent
-
-[options]
-zip_safe = False
-include_package_data = True
-package_dir =
-    = src
-py_modules =
-    microdot
-    microdot_asyncio
-    microdot_utemplate
-    microdot_jinja
-    microdot_session
-    microdot_test_client
-    microdot_asyncio_test_client
-    microdot_wsgi
-    microdot_asgi

setup.py

@@ -1,3 +0,0 @@
-import setuptools
-
-setuptools.setup()

src/microdot.py

@@ -43,20 +43,29 @@ try:
 except ImportError:
     import re
 
+socket_timeout_error = OSError
 try:
     import usocket as socket
 except ImportError:
     try:
         import socket
+        socket_timeout_error = socket.timeout
     except ImportError:  # pragma: no cover
         socket = None
 
+MUTED_SOCKET_ERRORS = [
+    32,  # Broken pipe
+    54,  # Connection reset by peer
+    104,  # Connection reset by peer
+    128,  # Operation on closed socket
+]
 
-def urldecode(string):
-    string = string.replace('+', ' ')
-    parts = string.split('%')
+
+def urldecode_str(s):
+    s = s.replace('+', ' ')
+    parts = s.split('%')
     if len(parts) == 1:
-        return string
+        return s
     result = [parts[0]]
     for item in parts[1:]:
         if item == '':
@@ -68,6 +77,113 @@ def urldecode(string):
     return ''.join(result)
 
 
+def urldecode_bytes(s):
+    s = s.replace(b'+', b' ')
+    parts = s.split(b'%')
+    if len(parts) == 1:
+        return s.decode()
+    result = [parts[0]]
+    for item in parts[1:]:
+        if item == b'':
+            result.append(b'%')
+        else:
+            code = item[:2]
+            result.append(bytes([int(code, 16)]))
+            result.append(item[2:])
+    return b''.join(result).decode()
+
+
+def urlencode(s):
+    return s.replace('+', '%2B').replace(' ', '+').replace(
+        '%', '%25').replace('?', '%3F').replace('#', '%23').replace(
+            '&', '%26').replace('=', '%3D')
+
+
+class NoCaseDict(dict):
+    """A subclass of dictionary that holds case-insensitive keys.
+
+    :param initial_dict: an initial dictionary of key/value pairs to
+                         initialize this object with.
+
+    Example::
+
+        >>> d = NoCaseDict()
+        >>> d['Content-Type'] = 'text/html'
+        >>> print(d['Content-Type'])
+        text/html
+        >>> print(d['content-type'])
+        text/html
+        >>> print(d['CONTENT-TYPE'])
+        text/html
+        >>> del d['cOnTeNt-TyPe']
+        >>> print(d)
+        {}
+    """
+    def __init__(self, initial_dict=None):
+        super().__init__(initial_dict or {})
+        self.keymap = {k.lower(): k for k in self.keys() if k.lower() != k}
+
+    def __setitem__(self, key, value):
+        kl = key.lower()
+        key = self.keymap.get(kl, key)
+        if kl != key:
+            self.keymap[kl] = key
+        super().__setitem__(key, value)
+
+    def __getitem__(self, key):
+        kl = key.lower()
+        return super().__getitem__(self.keymap.get(kl, kl))
+
+    def __delitem__(self, key):
+        kl = key.lower()
+        super().__delitem__(self.keymap.get(kl, kl))
+
+    def __contains__(self, key):
+        kl = key.lower()
+        return self.keymap.get(kl, kl) in self.keys()
+
+    def get(self, key, default=None):
+        kl = key.lower()
+        return super().get(self.keymap.get(kl, kl), default)
+
+    def update(self, other_dict):
+        for key, value in other_dict.items():
+            self[key] = value
+
+
+def mro(cls):  # pragma: no cover
+    """Return the method resolution order of a class.
+
+    This is a helper function that returns the method resolution order of a
+    class. It is used by Microdot to find the best error handler to invoke for
+    the raised exception.
+
+    In CPython, this function returns the ``__mro__`` attribute of the class.
+    In MicroPython, this function implements a recursive depth-first scanning
+    of the class hierarchy.
+    """
+    if hasattr(cls, 'mro'):
+        return cls.__mro__
+
+    def _mro(cls):
+        m = [cls]
+        for base in cls.__bases__:
+            m += _mro(base)
+        return m
+
+    mro_list = _mro(cls)
+
+    # If a class appears multiple times (due to multiple inheritance) remove
+    # all but the last occurence. This matches the method resolution order
+    # of MicroPython, but not CPython.
+    mro_pruned = []
+    for i in range(len(mro_list)):
+        base = mro_list.pop(0)
+        if base not in mro_list:
+            mro_pruned.append(base)
+    return mro_pruned
+
+
 class MultiDict(dict):
     """A subclass of dictionary that can hold multiple values for the same
     key. It is used to hold key/value pairs decoded from query strings and
@@ -190,17 +306,25 @@ class Request():
     #:    Request.max_readline = 16 * 1024  # 16KB lines allowed
     max_readline = 2 * 1024
 
+    #: Specify a suggested read timeout to use when reading the request. Set to
+    #: 0 to disable the use of a timeout. This timeout should be considered a
+    #: suggestion only, as some platforms may not support it. The default is
+    #: 1 second.
+    socket_read_timeout = 1
+
     class G:
         pass
 
     def __init__(self, app, client_addr, method, url, http_version, headers,
-                 body=None, stream=None):
+                 body=None, stream=None, sock=None):
         #: The application instance to which this request belongs.
         self.app = app
         #: The address of the client, as a tuple (host, port).
         self.client_addr = client_addr
         #: The HTTP method of the request.
         self.method = method
+        #: The request URL, including the path and query string.
+        self.url = url
         #: The path portion of the URL.
         self.path = url
         #: The query string portion of the URL.
@@ -225,33 +349,34 @@ class Request():
             self.path, self.query_string = self.path.split('?', 1)
             self.args = self._parse_urlencoded(self.query_string)
 
-        for header, value in self.headers.items():
-            header = header.lower()
-            if header == 'content-length':
-                self.content_length = int(value)
-            elif header == 'content-type':
-                self.content_type = value
-            elif header == 'cookie':
-                for cookie in value.split(';'):
-                    name, value = cookie.strip().split('=', 1)
-                    self.cookies[name] = value
+        if 'Content-Length' in self.headers:
+            self.content_length = int(self.headers['Content-Length'])
+        if 'Content-Type' in self.headers:
+            self.content_type = self.headers['Content-Type']
+        if 'Cookie' in self.headers:
+            for cookie in self.headers['Cookie'].split(';'):
+                name, value = cookie.strip().split('=', 1)
+                self.cookies[name] = value
 
         self._body = body
         self.body_used = False
         self._stream = stream
         self.stream_used = False
+        self.sock = sock
         self._json = None
         self._form = None
         self.after_request_handlers = []
 
     @staticmethod
-    def create(app, client_stream, client_addr):
+    def create(app, client_stream, client_addr, client_sock=None):
         """Create a request object.
 
+
         :param app: The Microdot application instance.
         :param client_stream: An input stream from where the request data can
                               be read.
         :param client_addr: The address of the client, as a tuple.
+        :param client_sock: The low-level socket associated with the request.
 
         This method returns a newly created ``Request`` object.
         """
@@ -263,7 +388,7 @@ class Request():
         http_version = http_version.split('/', 1)[1]
 
         # headers
-        headers = {}
+        headers = NoCaseDict()
         while True:
             line = Request._safe_readline(client_stream).strip().decode()
             if line == '':
@@ -273,13 +398,21 @@ class Request():
             headers[header] = value
 
         return Request(app, client_addr, method, url, http_version, headers,
-                       stream=client_stream)
+                       stream=client_stream, sock=client_sock)
 
     def _parse_urlencoded(self, urlencoded):
         data = MultiDict()
-        if urlencoded:
-            for k, v in [pair.split('=', 1) for pair in urlencoded.split('&')]:
-                data[urldecode(k)] = urldecode(v)
+        if len(urlencoded) > 0:
+            if isinstance(urlencoded, str):
+                for kv in [pair.split('=', 1)
+                           for pair in urlencoded.split('&') if pair]:
+                    data[urldecode_str(kv[0])] = urldecode_str(kv[1]) \
+                        if len(kv) > 1 else ''
+            elif isinstance(urlencoded, bytes):  # pragma: no branch
+                for kv in [pair.split(b'=', 1)
+                           for pair in urlencoded.split(b'&') if pair]:
+                    data[urldecode_bytes(kv[0])] = urldecode_bytes(kv[1]) \
+                        if len(kv) > 1 else b''
         return data
 
     @property
@@ -332,7 +465,7 @@ class Request():
             mime_type = self.content_type.split(';')[0]
             if mime_type != 'application/x-www-form-urlencoded':
                 return None
-            self._form = self._parse_urlencoded(self.body.decode())
+            self._form = self._parse_urlencoded(self.body)
         return self._form
 
     def after_request(self, f):
@@ -353,6 +486,9 @@ class Request():
                     return response
 
                 return 'Hello, World!'
+
+        Note that the function is not called if the request handler raises an
+        exception and an error response is returned instead.
         """
         self.after_request_handlers.append(f)
         return f
@@ -396,21 +532,30 @@ class Response():
     #: ``Content-Type`` header.
     default_content_type = 'text/plain'
 
+    #: The default cache control max age used by :meth:`send_file`. A value
+    #: of ``None`` means that no ``Cache-Control`` header is added.
+    default_send_file_max_age = None
+
+    #: Special response used to signal that a response does not need to be
+    #: written to the client. Used to exit WebSocket connections cleanly.
+    already_handled = None
+
     def __init__(self, body='', status_code=200, headers=None, reason=None):
         if body is None and status_code == 200:
             body = ''
             status_code = 204
         self.status_code = status_code
-        self.headers = headers.copy() if headers else {}
+        self.headers = NoCaseDict(headers or {})
         self.reason = reason
         if isinstance(body, (dict, list)):
             self.body = json.dumps(body).encode()
-            self.headers['Content-Type'] = 'application/json'
+            self.headers['Content-Type'] = 'application/json; charset=UTF-8'
         elif isinstance(body, str):
             self.body = body.encode()
         else:
             # this applies to bytes, file-like objects or generators
             self.body = body
+        self.is_head = False
 
     def set_cookie(self, cookie, value, path=None, domain=None, expires=None,
                    max_age=None, secure=False, http_only=False):
@@ -454,6 +599,8 @@ class Response():
             self.headers['Content-Length'] = str(len(self.body))
         if 'Content-Type' not in self.headers:
             self.headers['Content-Type'] = self.default_content_type
+            if 'charset=' not in self.headers['Content-Type']:
+                self.headers['Content-Type'] += '; charset=UTF-8'
 
     def write(self, stream):
         self.complete()
@@ -473,19 +620,20 @@ class Response():
         stream.write(b'\r\n')
 
         # body
-        can_flush = hasattr(stream, 'flush')
-        try:
-            for body in self.body_iter():
-                if isinstance(body, str):  # pragma: no cover
-                    body = body.encode()
-                stream.write(body)
-                if can_flush:  # pragma: no cover
-                    stream.flush()
-        except OSError as exc:  # pragma: no cover
-            if exc.errno == 32:  # errno.EPIPE
-                pass
-            else:
-                raise
+        if not self.is_head:
+            can_flush = hasattr(stream, 'flush')
+            try:
+                for body in self.body_iter():
+                    if isinstance(body, str):  # pragma: no cover
+                        body = body.encode()
+                    stream.write(body)
+                    if can_flush:  # pragma: no cover
+                        stream.flush()
+            except OSError as exc:  # pragma: no cover
+                if exc.errno in MUTED_SOCKET_ERRORS:
+                    pass
+                else:
+                    raise
 
     def body_iter(self):
         if self.body:
@@ -516,7 +664,9 @@ class Response():
         return cls(status_code=status_code, headers={'Location': location})
 
     @classmethod
-    def send_file(cls, filename, status_code=200, content_type=None):
+    def send_file(cls, filename, status_code=200, content_type=None,
+                  stream=None, max_age=None, compressed=False,
+                  file_extension=''):
         """Send file contents in a response.
 
         :param filename: The filename of the file.
@@ -524,7 +674,25 @@ class Response():
                             default is 302.
         :param content_type: The ``Content-Type`` header to use in the
                              response. If omitted, it is generated
-                             automatically from the file extension.
+                             automatically from the file extension of the
+                             ``filename`` parameter.
+        :param stream: A file-like object to read the file contents from. If
+                       a stream is given, the ``filename`` parameter is only
+                       used when generating the ``Content-Type`` header.
+        :param max_age: The ``Cache-Control`` header's ``max-age`` value in
+                        seconds. If omitted, the value of the
+                        :attr:`Response.default_send_file_max_age` attribute is
+                        used.
+        :param compressed: Whether the file is compressed. If ``True``, the
+                           ``Content-Encoding`` header is set to ``gzip``. A
+                           string with the header value can also be passed.
+                           Note that when using this option the file must have
+                           been compressed beforehand. This option only sets
+                           the header.
+        :param file_extension: A file extension to append to the ``filename``
+                               parameter when opening the file, including the
+                               dot. The extension given here is not considered
+                               when generating the ``Content-Type`` header.
 
         Security note: The filename is assumed to be trusted. Never pass
         filenames provided by the user without validating and sanitizing them
@@ -536,9 +704,19 @@ class Response():
                 content_type = Response.types_map[ext]
             else:
                 content_type = 'application/octet-stream'
-        f = open(filename, 'rb')
-        return cls(body=f, status_code=status_code,
-                   headers={'Content-Type': content_type})
+        headers = {'Content-Type': content_type}
+
+        if max_age is None:
+            max_age = cls.default_send_file_max_age
+        if max_age is not None:
+            headers['Cache-Control'] = 'max-age={}'.format(max_age)
+
+        if compressed:
+            headers['Content-Encoding'] = compressed \
+                if isinstance(compressed, str) else 'gzip'
+
+        f = stream or open(filename + file_extension, 'rb')
+        return cls(body=f, status_code=status_code, headers=headers)
 
 
 class URLPattern():
@@ -560,7 +738,7 @@ class URLPattern():
                 if type_ == 'string':
                     pattern = '[^/]+'
                 elif type_ == 'int':
-                    pattern = '\\d+'
+                    pattern = '-?\\d+'
                 elif type_ == 'path':
                     pattern = '.+'
                 elif type_.startswith('re:'):
@@ -594,6 +772,15 @@ class URLPattern():
         return args
 
 
+class HTTPException(Exception):
+    def __init__(self, status_code, reason=None):
+        self.status_code = status_code
+        self.reason = reason or str(status_code) + ' error'
+
+    def __repr__(self):  # pragma: no cover
+        return 'HTTPException: {}'.format(self.status_code)
+
+
 class Microdot():
     """An HTTP application class.
 
@@ -612,8 +799,10 @@ class Microdot():
         self.url_map = []
         self.before_request_handlers = []
         self.after_request_handlers = []
+        self.after_error_request_handlers = []
         self.error_handlers = {}
         self.shutdown_requested = False
+        self.options_handler = self.default_options_handler
         self.debug = False
         self.server = None
 
@@ -649,7 +838,8 @@ class Microdot():
         """
         def decorated(f):
             self.url_map.append(
-                (methods or ['GET'], URLPattern(url_pattern), f))
+                ([m.upper() for m in (methods or ['GET'])],
+                 URLPattern(url_pattern), f))
             return f
         return decorated
 
@@ -773,6 +963,24 @@ class Microdot():
         self.after_request_handlers.append(f)
         return f
 
+    def after_error_request(self, f):
+        """Decorator to register a function to run after an error response is
+        generated. The decorated function must take two arguments, the request
+        and response objects. The return value of the function must be an
+        updated response object. The handler is invoked for error responses
+        generated by Microdot, as well as those returned by application-defined
+        error handlers.
+
+        Example::
+
+            @app.after_error_request
+            def func(request, response):
+                # ...
+                return response
+        """
+        self.after_error_request_handlers.append(f)
+        return f
+
     def errorhandler(self, status_code_or_exception_class):
         """Decorator to register a function as an error handler. Error handler
         functions for numeric HTTP status codes must accept a single argument,
@@ -813,10 +1021,34 @@ class Microdot():
             self.before_request_handlers.append(handler)
         for handler in subapp.after_request_handlers:
             self.after_request_handlers.append(handler)
+        for handler in subapp.after_error_request_handlers:
+            self.after_error_request_handlers.append(handler)
         for status_code, handler in subapp.error_handlers.items():
             self.error_handlers[status_code] = handler
 
-    def run(self, host='0.0.0.0', port=5000, debug=False):
+    @staticmethod
+    def abort(status_code, reason=None):
+        """Abort the current request and return an error response with the
+        given status code.
+
+        :param status_code: The numeric status code of the response.
+        :param reason: The reason for the response, which is included in the
+                       response body.
+
+        Example::
+
+            from microdot import abort
+
+            @app.route('/users/<int:id>')
+            def get_user(id):
+                user = get_user_by_id(id)
+                if user is None:
+                    abort(404)
+                return user.to_dict()
+        """
+        raise HTTPException(status_code, reason)
+
+    def run(self, host='0.0.0.0', port=5000, debug=False, ssl=None):
         """Start the web server. This function does not normally return, as
         the server enters an endless listening loop. The :func:`shutdown`
         function provides a method for terminating the server gracefully.
@@ -832,6 +1064,8 @@ class Microdot():
                      port 5000.
         :param debug: If ``True``, the server logs debugging information. The
                       default is ``False``.
+        :param ssl: An ``SSLContext`` instance or ``None`` if the server should
+                    not use TLS. The default is ``None``.
 
         Example::
 
@@ -840,7 +1074,7 @@ class Microdot():
             app = Microdot()
 
             @app.route('/')
-            def index():
+            def index(request):
                 return 'Hello, world!'
 
             app.run(debug=True)
@@ -859,6 +1093,9 @@ class Microdot():
         self.server.bind(addr)
         self.server.listen(5)
 
+        if ssl:
+            self.server = ssl.wrap_socket(self.server, server_side=True)
+
         while not self.shutdown_requested:
             try:
                 sock, addr = self.server.accept()
@@ -866,8 +1103,11 @@ class Microdot():
                 if exc.errno == errno.ECONNABORTED:
                     break
                 else:
-                    raise
-            create_thread(self.handle_request, sock, addr)
+                    print_exception(exc)
+            except Exception as exc:  # pragma: no cover
+                print_exception(exc)
+            else:
+                create_thread(self.handle_request, sock, addr)
 
     def shutdown(self):
         """Request a server shutdown. The server will then exit its request
@@ -885,37 +1125,62 @@ class Microdot():
         self.shutdown_requested = True
 
     def find_route(self, req):
+        method = req.method.upper()
+        if method == 'OPTIONS' and self.options_handler:
+            return self.options_handler(req)
+        if method == 'HEAD':
+            method = 'GET'
         f = 404
         for route_methods, route_pattern, route_handler in self.url_map:
             req.url_args = route_pattern.match(req.path)
             if req.url_args is not None:
-                if req.method in route_methods:
+                if method in route_methods:
                     f = route_handler
                     break
                 else:
                     f = 405
         return f
 
+    def default_options_handler(self, req):
+        allow = []
+        for route_methods, route_pattern, route_handler in self.url_map:
+            if route_pattern.match(req.path) is not None:
+                allow.extend(route_methods)
+        if 'GET' in allow:
+            allow.append('HEAD')
+        allow.append('OPTIONS')
+        return {'Allow': ', '.join(allow)}
+
     def handle_request(self, sock, addr):
+        if Request.socket_read_timeout and \
+                hasattr(sock, 'settimeout'):  # pragma: no cover
+            sock.settimeout(Request.socket_read_timeout)
         if not hasattr(sock, 'readline'):  # pragma: no cover
             stream = sock.makefile("rwb")
         else:
             stream = sock
 
         req = None
+        res = None
         try:
-            req = Request.create(self, stream, addr)
+            req = Request.create(self, stream, addr, sock)
+            res = self.dispatch_request(req)
+        except socket_timeout_error as exc:  # pragma: no cover
+            if exc.errno and exc.errno != errno.ETIMEDOUT:
+                print_exception(exc)  # not a timeout
         except Exception as exc:  # pragma: no cover
             print_exception(exc)
-        res = self.dispatch_request(req)
-        res.write(stream)
         try:
+            if res and res != Response.already_handled:  # pragma: no branch
+                res.write(stream)
             stream.close()
         except OSError as exc:  # pragma: no cover
-            if exc.errno == 32:  # errno.EPIPE
+            if exc.errno in MUTED_SOCKET_ERRORS:
                 pass
             else:
-                raise
+                print_exception(exc)
+        except Exception as exc:  # pragma: no cover
+            print_exception(exc)
         if stream != sock:  # pragma: no cover
             sock.close()
         if self.shutdown_requested:  # pragma: no cover
@@ -926,6 +1191,7 @@ class Microdot():
                 status_code=res.status_code))
 
     def dispatch_request(self, req):
+        after_request_handled = False
         if req:
             if req.content_length > req.max_content_length:
                 if 413 in self.error_handlers:
@@ -958,16 +1224,32 @@ class Microdot():
                             res = handler(req, res) or res
                         for handler in req.after_request_handlers:
                             res = handler(req, res) or res
+                        after_request_handled = True
+                    elif isinstance(f, dict):
+                        res = Response(headers=f)
                     elif f in self.error_handlers:
                         res = self.error_handlers[f](req)
                     else:
                         res = 'Not found', f
+                except HTTPException as exc:
+                    if exc.status_code in self.error_handlers:
+                        res = self.error_handlers[exc.status_code](req)
+                    else:
+                        res = exc.reason, exc.status_code
                 except Exception as exc:
                     print_exception(exc)
+                    exc_class = None
                     res = None
                     if exc.__class__ in self.error_handlers:
+                        exc_class = exc.__class__
+                    else:
+                        for c in mro(exc.__class__)[1:]:
+                            if c in self.error_handlers:
+                                exc_class = c
+                                break
+                    if exc_class:
                         try:
-                            res = self.error_handlers[exc.__class__](req, exc)
+                            res = self.error_handlers[exc_class](req, exc)
                         except Exception as exc2:  # pragma: no cover
                             print_exception(exc2)
                     if res is None:
@@ -985,8 +1267,14 @@ class Microdot():
             res = Response(*res)
         elif not isinstance(res, Response):
             res = Response(res)
+        if not after_request_handled:
+            for handler in self.after_error_request_handlers:
+                res = handler(req, res) or res
+        res.is_head = (req and req.method == 'HEAD')
         return res
 
 
+abort = Microdot.abort
+Response.already_handled = Response()
 redirect = Response.redirect
 send_file = Response.send_file

src/microdot_asgi.py

@@ -4,6 +4,7 @@ import signal
 from microdot_asyncio import *  # noqa: F401, F403
 from microdot_asyncio import Microdot as BaseMicrodot
 from microdot_asyncio import Request
+from microdot import NoCaseDict
 
 
 class _BodyStream:  # pragma: no cover
@@ -50,19 +51,19 @@ class Microdot(BaseMicrodot):
 
     async def asgi_app(self, scope, receive, send):
         """An ASGI application."""
-        if scope['type'] != 'http':  # pragma: no cover
+        if scope['type'] not in ['http', 'websocket']:  # pragma: no cover
             return
         path = scope['path']
         if 'query_string' in scope and scope['query_string']:
             path += '?' + scope['query_string'].decode()
-        headers = {}
+        headers = NoCaseDict()
         content_length = 0
         for key, value in scope.get('headers', []):
-            headers[key] = value
-            if key.lower() == 'content-length':
+            key = key.decode().title()
+            headers[key] = value.decode()
+            if key == 'Content-Length':
                 content_length = int(value)
 
-        body = b''
         if content_length and content_length <= Request.max_body_length:
             body = b''
             more = True
@@ -78,12 +79,13 @@ class Microdot(BaseMicrodot):
         req = Request(
             self,
             (scope['client'][0], scope['client'][1]),
-            scope['method'],
+            scope.get('method', 'GET'),
             path,
             'HTTP/' + scope['http_version'],
             headers,
             body=body,
-            stream=stream)
+            stream=stream,
+            sock=(receive, send))
         req.asgi_scope = scope
 
         res = await self.dispatch_request(req)
@@ -92,10 +94,13 @@ class Microdot(BaseMicrodot):
         header_list = []
         for name, value in res.headers.items():
             if not isinstance(value, list):
-                header_list.append((name, value))
+                header_list.append((name.lower().encode(), value.encode()))
             else:
                 for v in value:
-                    header_list.append((name, v))
+                    header_list.append((name.lower().encode(), v.encode()))
+
+        if scope['type'] != 'http':  # pragma: no cover
+            return
 
         await send({'type': 'http.response.start',
                     'status': res.status_code,
@@ -115,17 +120,18 @@ class Microdot(BaseMicrodot):
         asyncio.ensure_future(cancel_monitor())
 
         body_iter = res.body_iter().__aiter__()
+        res_body = b''
         try:
-            body = await body_iter.__anext__()
+            res_body = await body_iter.__anext__()
             while not cancelled:  # pragma: no branch
                 next_body = await body_iter.__anext__()
                 await send({'type': 'http.response.body',
-                            'body': body,
+                            'body': res_body,
                             'more_body': True})
-                body = next_body
+                res_body = next_body
         except StopAsyncIteration:
             await send({'type': 'http.response.body',
-                        'body': body,
+                        'body': res_body,
                         'more_body': False})
 
     async def __call__(self, scope, receive, send):

src/microdot_asgi_websocket.py

@@ -0,0 +1,86 @@
+from microdot_asyncio import Response, abort
+from microdot_websocket import WebSocket as BaseWebSocket
+
+
+class WebSocket(BaseWebSocket):
+    async def handshake(self):
+        connect = await self.request.sock[0]()
+        if connect['type'] != 'websocket.connect':
+            abort(400)
+        await self.request.sock[1]({'type': 'websocket.accept'})
+
+    async def receive(self):
+        message = await self.request.sock[0]()
+        if message['type'] == 'websocket.disconnect':
+            raise OSError(32, 'Websocket connection closed')
+        elif message['type'] != 'websocket.receive':
+            raise OSError(32, 'Websocket message type not supported')
+        return message.get('bytes', message.get('text'))
+
+    async def send(self, data):
+        if isinstance(data, str):
+            await self.request.sock[1](
+                {'type': 'websocket.send', 'text': data})
+        else:
+            await self.request.sock[1](
+                {'type': 'websocket.send', 'bytes': data})
+
+    async def close(self):
+        if not self.closed:
+            self.closed = True
+            try:
+                await self.request.sock[1]({'type': 'websocket.close'})
+            except:  # noqa E722
+                pass
+
+
+async def websocket_upgrade(request):
+    """Upgrade a request handler to a websocket connection.
+
+    This function can be called directly inside a route function to process a
+    WebSocket upgrade handshake, for example after the user's credentials are
+    verified. The function returns the websocket object::
+
+        @app.route('/echo')
+        async def echo(request):
+            if not (await authenticate_user(request)):
+                abort(401)
+            ws = await websocket_upgrade(request)
+            while True:
+                message = await ws.receive()
+                await ws.send(message)
+    """
+    ws = WebSocket(request)
+    await ws.handshake()
+
+    @request.after_request
+    async def after_request(request, response):
+        return Response.already_handled
+
+    return ws
+
+
+def with_websocket(f):
+    """Decorator to make a route a WebSocket endpoint.
+
+    This decorator is used to define a route that accepts websocket
+    connections. The route then receives a websocket object as a second
+    argument that it can use to send and receive messages::
+
+        @app.route('/echo')
+        @with_websocket
+        async def echo(request, ws):
+            while True:
+                message = await ws.receive()
+                await ws.send(message)
+    """
+    async def wrapper(request, *args, **kwargs):
+        ws = await websocket_upgrade(request)
+        try:
+            await f(request, ws, *args, **kwargs)
+        except OSError as exc:
+            if exc.errno != 32 and exc.errno != 54:
+                raise
+        await ws.close()
+        return ''
+    return wrapper

src/microdot_asyncio.py

@@ -17,9 +17,13 @@ except ImportError:
     import io
 
 from microdot import Microdot as BaseMicrodot
-from microdot import print_exception
+from microdot import mro
+from microdot import NoCaseDict
 from microdot import Request as BaseRequest
 from microdot import Response as BaseResponse
+from microdot import print_exception
+from microdot import HTTPException
+from microdot import MUTED_SOCKET_ERRORS
 
 
 def _iscoroutine(coro):
@@ -42,33 +46,41 @@ class _AsyncBytesIO:
     async def readuntil(self, separator=b'\n'):  # pragma: no cover
         return self.stream.readuntil(separator=separator)
 
+    async def awrite(self, data):  # pragma: no cover
+        return self.stream.write(data)
+
+    async def aclose(self):  # pragma: no cover
+        pass
+
 
 class Request(BaseRequest):
     @staticmethod
-    async def create(app, client_stream, client_addr):
+    async def create(app, client_reader, client_writer, client_addr):
         """Create a request object.
 
         :param app: The Microdot application instance.
-        :param client_stream: An input stream from where the request data can
+        :param client_reader: An input stream from where the request data can
                               be read.
+        :param client_writer: An output stream where the response data can be
+                              written.
         :param client_addr: The address of the client, as a tuple.
 
         This method is a coroutine. It returns a newly created ``Request``
         object.
         """
         # request line
-        line = (await Request._safe_readline(client_stream)).strip().decode()
+        line = (await Request._safe_readline(client_reader)).strip().decode()
         if not line:
             return None
         method, url, http_version = line.split()
         http_version = http_version.split('/', 1)[1]
 
         # headers
-        headers = {}
+        headers = NoCaseDict()
         content_length = 0
         while True:
             line = (await Request._safe_readline(
-                client_stream)).strip().decode()
+                client_reader)).strip().decode()
             if line == '':
                 break
             header, value = line.split(':', 1)
@@ -80,14 +92,15 @@ class Request(BaseRequest):
         # body
         body = b''
         if content_length and content_length <= Request.max_body_length:
-            body = await client_stream.readexactly(content_length)
+            body = await client_reader.readexactly(content_length)
             stream = None
         else:
             body = b''
-            stream = client_stream
+            stream = client_reader
 
         return Request(app, client_addr, method, url, http_version, headers,
-                       body=body, stream=stream)
+                       body=body, stream=stream,
+                       sock=(client_reader, client_writer))
 
     @property
     def stream(self):
@@ -118,31 +131,34 @@ class Response(BaseResponse):
                    default is "OK" for responses with a 200 status code and
                    "N/A" for any other status codes.
     """
+
     async def write(self, stream):
         self.complete()
 
-        # status code
-        reason = self.reason if self.reason is not None else \
-            ('OK' if self.status_code == 200 else 'N/A')
-        await stream.awrite('HTTP/1.0 {status_code} {reason}\r\n'.format(
-            status_code=self.status_code, reason=reason).encode())
-
-        # headers
-        for header, value in self.headers.items():
-            values = value if isinstance(value, list) else [value]
-            for value in values:
-                await stream.awrite('{header}: {value}\r\n'.format(
-                    header=header, value=value).encode())
-        await stream.awrite(b'\r\n')
-
-        # body
         try:
-            async for body in self.body_iter():
-                if isinstance(body, str):  # pragma: no cover
-                    body = body.encode()
-                await stream.awrite(body)
+            # status code
+            reason = self.reason if self.reason is not None else \
+                ('OK' if self.status_code == 200 else 'N/A')
+            await stream.awrite('HTTP/1.0 {status_code} {reason}\r\n'.format(
+                status_code=self.status_code, reason=reason).encode())
+
+            # headers
+            for header, value in self.headers.items():
+                values = value if isinstance(value, list) else [value]
+                for value in values:
+                    await stream.awrite('{header}: {value}\r\n'.format(
+                        header=header, value=value).encode())
+            await stream.awrite(b'\r\n')
+
+            # body
+            if not self.is_head:
+                async for body in self.body_iter():
+                    if isinstance(body, str):  # pragma: no cover
+                        body = body.encode()
+                    await stream.awrite(body)
         except OSError as exc:  # pragma: no cover
-            if exc.errno == 32 or exc.args[0] == 'Connection lost':
+            if exc.errno in MUTED_SOCKET_ERRORS or \
+                    exc.args[0] == 'Connection lost':
                 pass
             else:
                 raise
@@ -194,7 +210,8 @@ class Response(BaseResponse):
 
 
 class Microdot(BaseMicrodot):
-    async def start_server(self, host='0.0.0.0', port=5000, debug=False):
+    async def start_server(self, host='0.0.0.0', port=5000, debug=False,
+                           ssl=None):
         """Start the Microdot web server as a coroutine. This coroutine does
         not normally return, as the server enters an endless listening loop.
         The :func:`shutdown` function provides a method for terminating the
@@ -211,6 +228,8 @@ class Microdot(BaseMicrodot):
                      port 5000.
         :param debug: If ``True``, the server logs debugging information. The
                       default is ``False``.
+        :param ssl: An ``SSLContext`` instance or ``None`` if the server should
+                    not use TLS. The default is ``None``.
 
         This method is a coroutine.
 
@@ -222,7 +241,7 @@ class Microdot(BaseMicrodot):
             app = Microdot()
 
             @app.route('/')
-            async def index():
+            async def index(request):
                 return 'Hello, world!'
 
             async def main():
@@ -253,9 +272,19 @@ class Microdot(BaseMicrodot):
             print('Starting async server on {host}:{port}...'.format(
                 host=host, port=port))
 
-        self.server = await asyncio.start_server(serve, host, port)
+        try:
+            self.server = await asyncio.start_server(serve, host, port,
+                                                     ssl=ssl)
+        except TypeError:
+            self.server = await asyncio.start_server(serve, host, port)
+
         while True:
             try:
+                if hasattr(self.server, 'serve_forever'):  # pragma: no cover
+                    try:
+                        await self.server.serve_forever()
+                    except asyncio.CancelledError:
+                        pass
                 await self.server.wait_closed()
                 break
             except AttributeError:  # pragma: no cover
@@ -263,7 +292,7 @@ class Microdot(BaseMicrodot):
                 # wait a bit and try again
                 await asyncio.sleep(0.1)
 
-    def run(self, host='0.0.0.0', port=5000, debug=False):
+    def run(self, host='0.0.0.0', port=5000, debug=False, ssl=None):
         """Start the web server. This function does not normally return, as
         the server enters an endless listening loop. The :func:`shutdown`
         function provides a method for terminating the server gracefully.
@@ -279,6 +308,8 @@ class Microdot(BaseMicrodot):
                      port 5000.
         :param debug: If ``True``, the server logs debugging information. The
                       default is ``False``.
+        :param ssl: An ``SSLContext`` instance or ``None`` if the server should
+                    not use TLS. The default is ``None``.
 
         Example::
 
@@ -287,12 +318,13 @@ class Microdot(BaseMicrodot):
             app = Microdot()
 
             @app.route('/')
-            async def index():
+            async def index(request):
                 return 'Hello, world!'
 
             app.run(debug=True)
         """
-        asyncio.run(self.start_server(host=host, port=port, debug=debug))
+        asyncio.run(self.start_server(host=host, port=port, debug=debug,
+                                      ssl=ssl))
 
     def shutdown(self):
         self.server.close()
@@ -300,17 +332,18 @@ class Microdot(BaseMicrodot):
     async def handle_request(self, reader, writer):
         req = None
         try:
-            req = await Request.create(self, reader,
+            req = await Request.create(self, reader, writer,
                                        writer.get_extra_info('peername'))
         except Exception as exc:  # pragma: no cover
             print_exception(exc)
 
         res = await self.dispatch_request(req)
-        await res.write(writer)
+        if res != Response.already_handled:  # pragma: no branch
+            await res.write(writer)
         try:
             await writer.aclose()
         except OSError as exc:  # pragma: no cover
-            if exc.errno == 32:  # errno.EPIPE
+            if exc.errno in MUTED_SOCKET_ERRORS:
                 pass
             else:
                 raise
@@ -320,6 +353,7 @@ class Microdot(BaseMicrodot):
                 status_code=res.status_code))
 
     async def dispatch_request(self, req):
+        after_request_handled = False
         if req:
             if req.content_length > req.max_content_length:
                 if 413 in self.error_handlers:
@@ -354,19 +388,36 @@ class Microdot(BaseMicrodot):
                             res = await self._invoke_handler(
                                 handler, req, res) or res
                         for handler in req.after_request_handlers:
-                            res = await handler(req, res) or res
+                            res = await self._invoke_handler(
+                                handler, req, res) or res
+                        after_request_handled = True
+                    elif isinstance(f, dict):
+                        res = Response(headers=f)
                     elif f in self.error_handlers:
                         res = await self._invoke_handler(
                             self.error_handlers[f], req)
                     else:
                         res = 'Not found', f
+                except HTTPException as exc:
+                    if exc.status_code in self.error_handlers:
+                        res = self.error_handlers[exc.status_code](req)
+                    else:
+                        res = exc.reason, exc.status_code
                 except Exception as exc:
                     print_exception(exc)
+                    exc_class = None
                     res = None
                     if exc.__class__ in self.error_handlers:
+                        exc_class = exc.__class__
+                    else:
+                        for c in mro(exc.__class__)[1:]:
+                            if c in self.error_handlers:
+                                exc_class = c
+                                break
+                    if exc_class:
                         try:
                             res = await self._invoke_handler(
-                                self.error_handlers[exc.__class__], req, exc)
+                                self.error_handlers[exc_class], req, exc)
                         except Exception as exc2:  # pragma: no cover
                             print_exception(exc2)
                     if res is None:
@@ -384,6 +435,11 @@ class Microdot(BaseMicrodot):
             res = Response(*res)
         elif not isinstance(res, Response):
             res = Response(res)
+        if not after_request_handled:
+            for handler in self.after_error_request_handlers:
+                res = await self._invoke_handler(
+                    handler, req, res) or res
+        res.is_head = (req and req.method == 'HEAD')
         return res
 
     async def _invoke_handler(self, f_or_coro, *args, **kwargs):
@@ -393,5 +449,7 @@ class Microdot(BaseMicrodot):
         return ret
 
 
+abort = Microdot.abort
+Response.already_handled = Response()
 redirect = Response.redirect
 send_file = Response.send_file

src/microdot_asyncio_test_client.py

@@ -1,6 +1,10 @@
-from microdot_asyncio import Request, _AsyncBytesIO
+from microdot_asyncio import Request, Response, _AsyncBytesIO
 from microdot_test_client import TestClient as BaseTestClient, \
     TestResponse as BaseTestResponse
+try:
+    from microdot_asyncio_websocket import WebSocket
+except:  # pragma: no cover  # noqa: E722
+    WebSocket = None
 
 
 class TestResponse(BaseTestResponse):
@@ -17,7 +21,7 @@ class TestResponse(BaseTestResponse):
 
     async def _initialize_body(self, res):
         self.body = b''
-        async for body in res.body_iter():
+        async for body in res.body_iter():  # pragma: no branch
             if isinstance(body, str):
                 body = body.encode()
             self.body += body
@@ -47,15 +51,24 @@ class TestClient(BaseTestClient):
             assert res.status_code == 200
             assert res.text == 'Hello, World!'
     """
-    async def request(self, method, path, headers=None, body=None):
+    async def request(self, method, path, headers=None, body=None, sock=None):
         headers = headers or {}
         body, headers = self._process_body(body, headers)
         cookies, headers = self._process_cookies(headers)
         request_bytes = self._render_request(method, path, headers, body)
+        if sock:
+            reader = sock[0]
+            reader.buffer = request_bytes
+            writer = sock[1]
+        else:
+            reader = _AsyncBytesIO(request_bytes)
+            writer = _AsyncBytesIO(b'')
 
-        req = await Request.create(self.app, _AsyncBytesIO(request_bytes),
+        req = await Request.create(self.app, reader, writer,
                                    ('127.0.0.1', 1234))
         res = await self.app.dispatch_request(req)
+        if res == Response.already_handled:
+            return None
         res.complete()
 
         self._update_cookies(res)
@@ -124,3 +137,72 @@ class TestClient(BaseTestClient):
         :class:`TestResponse <microdot_test_client.TestResponse>` object.
         """
         return await self.request('DELETE', path, headers=headers)
+
+    async def websocket(self, path, client, headers=None):
+        """Send a websocket connection request to the application.
+
+        :param path: The request URL.
+        :param client: A generator function that yields client messages.
+        :param headers: A dictionary of headers to send with the request.
+        """
+        gen = client()
+
+        class FakeWebSocket:
+            def __init__(self):
+                self.started = False
+                self.closed = False
+                self.buffer = b''
+
+            async def _next(self, data=None):
+                try:
+                    data = (await gen.asend(data)) if hasattr(gen, 'asend') \
+                        else gen.send(data)
+                except (StopIteration, StopAsyncIteration):
+                    if not self.closed:
+                        self.closed = True
+                        raise OSError(32, 'Websocket connection closed')
+                    return  # pragma: no cover
+                opcode = WebSocket.TEXT if isinstance(data, str) \
+                    else WebSocket.BINARY
+                return WebSocket._encode_websocket_frame(opcode, data)
+
+            async def read(self, n):
+                if not self.buffer:
+                    self.started = True
+                    self.buffer = await self._next()
+                data = self.buffer[:n]
+                self.buffer = self.buffer[n:]
+                return data
+
+            async def readexactly(self, n):  # pragma: no cover
+                return await self.read(n)
+
+            async def readline(self):
+                line = b''
+                while True:
+                    line += await self.read(1)
+                    if line[-1] in [b'\n', 10]:
+                        break
+                return line
+
+            async def awrite(self, data):
+                if self.started:
+                    h = WebSocket._parse_frame_header(data[0:2])
+                    if h[3] < 0:
+                        data = data[2 - h[3]:]
+                    else:
+                        data = data[2:]
+                    if h[1] == WebSocket.TEXT:
+                        data = data.decode()
+                    self.buffer = await self._next(data)
+
+        ws_headers = {
+            'Upgrade': 'websocket',
+            'Connection': 'Upgrade',
+            'Sec-WebSocket-Version': '13',
+            'Sec-WebSocket-Key': 'dGhlIHNhbXBsZSBub25jZQ==',
+        }
+        ws_headers.update(headers or {})
+        sock = FakeWebSocket()
+        return await self.request('GET', path, headers=ws_headers,
+                                  sock=(sock, sock))

src/microdot_asyncio_websocket.py

@@ -0,0 +1,103 @@
+from microdot_asyncio import Response
+from microdot_websocket import WebSocket as BaseWebSocket
+
+
+class WebSocket(BaseWebSocket):
+    async def handshake(self):
+        response = self._handshake_response()
+        await self.request.sock[1].awrite(
+            b'HTTP/1.1 101 Switching Protocols\r\n')
+        await self.request.sock[1].awrite(b'Upgrade: websocket\r\n')
+        await self.request.sock[1].awrite(b'Connection: Upgrade\r\n')
+        await self.request.sock[1].awrite(
+            b'Sec-WebSocket-Accept: ' + response + b'\r\n\r\n')
+
+    async def receive(self):
+        while True:
+            opcode, payload = await self._read_frame()
+            send_opcode, data = self._process_websocket_frame(opcode, payload)
+            if send_opcode:  # pragma: no cover
+                await self.send(data, send_opcode)
+            elif data:  # pragma: no branch
+                return data
+
+    async def send(self, data, opcode=None):
+        frame = self._encode_websocket_frame(
+            opcode or (self.TEXT if isinstance(data, str) else self.BINARY),
+            data)
+        await self.request.sock[1].awrite(frame)
+
+    async def close(self):
+        if not self.closed:  # pragma: no cover
+            self.closed = True
+            await self.send(b'', self.CLOSE)
+
+    async def _read_frame(self):
+        header = await self.request.sock[0].read(2)
+        if len(header) != 2:  # pragma: no cover
+            raise OSError(32, 'Websocket connection closed')
+        fin, opcode, has_mask, length = self._parse_frame_header(header)
+        if length == -2:
+            length = await self.request.sock[0].read(2)
+            length = int.from_bytes(length, 'big')
+        elif length == -8:
+            length = await self.request.sock[0].read(8)
+            length = int.from_bytes(length, 'big')
+        if has_mask:  # pragma: no cover
+            mask = await self.request.sock[0].read(4)
+        payload = await self.request.sock[0].read(length)
+        if has_mask:  # pragma: no cover
+            payload = bytes(x ^ mask[i % 4] for i, x in enumerate(payload))
+        return opcode, payload
+
+
+async def websocket_upgrade(request):
+    """Upgrade a request handler to a websocket connection.
+
+    This function can be called directly inside a route function to process a
+    WebSocket upgrade handshake, for example after the user's credentials are
+    verified. The function returns the websocket object::
+
+        @app.route('/echo')
+        async def echo(request):
+            if not authenticate_user(request):
+                abort(401)
+            ws = await websocket_upgrade(request)
+            while True:
+                message = await ws.receive()
+                await ws.send(message)
+    """
+    ws = WebSocket(request)
+    await ws.handshake()
+
+    @request.after_request
+    async def after_request(request, response):
+        return Response.already_handled
+
+    return ws
+
+
+def with_websocket(f):
+    """Decorator to make a route a WebSocket endpoint.
+
+    This decorator is used to define a route that accepts websocket
+    connections. The route then receives a websocket object as a second
+    argument that it can use to send and receive messages::
+
+        @app.route('/echo')
+        @with_websocket
+        async def echo(request, ws):
+            while True:
+                message = await ws.receive()
+                await ws.send(message)
+    """
+    async def wrapper(request, *args, **kwargs):
+        ws = await websocket_upgrade(request)
+        try:
+            await f(request, ws, *args, **kwargs)
+            await ws.close()  # pragma: no cover
+        except OSError as exc:
+            if exc.errno not in [32, 54, 104]:  # pragma: no cover
+                raise
+        return ''
+    return wrapper

src/microdot_cors.py

@@ -0,0 +1,110 @@
+class CORS:
+    """Add CORS headers to HTTP responses.
+
+    :param app: The application to add CORS headers to.
+    :param allowed_origins: A list of origins that are allowed to make
+                            cross-site requests. If set to '*', all origins are
+                            allowed.
+    :param allow_credentials: If set to True, the
+                              ``Access-Control-Allow-Credentials`` header will
+                              be set to ``true`` to indicate to the browser
+                              that it can expose cookies and authentication
+                              headers.
+    :param allowed_methods: A list of methods that are allowed to be used when
+                            making cross-site requests. If not set, all methods
+                            are allowed.
+    :param expose_headers: A list of headers that the browser is allowed to
+                           exposed.
+    :param allowed_headers: A list of headers that are allowed to be used when
+                            making cross-site requests. If not set, all headers
+                            are allowed.
+    :param max_age: The maximum amount of time in seconds that the browser
+                    should cache the results of a preflight request.
+    :param handle_cors: If set to False, CORS headers will not be added to
+                        responses. This can be useful if you want to add CORS
+                        headers manually.
+    """
+    def __init__(self, app=None, allowed_origins=None, allow_credentials=False,
+                 allowed_methods=None, expose_headers=None,
+                 allowed_headers=None, max_age=None, handle_cors=True):
+        self.allowed_origins = allowed_origins
+        self.allow_credentials = allow_credentials
+        self.allowed_methods = allowed_methods
+        self.expose_headers = expose_headers
+        self.allowed_headers = None if allowed_headers is None \
+            else [h.lower() for h in allowed_headers]
+        self.max_age = max_age
+        if app is not None:
+            self.initialize(app, handle_cors=handle_cors)
+
+    def initialize(self, app, handle_cors=True):
+        """Initialize the CORS object for the given application.
+
+        :param app: The application to add CORS headers to.
+        :param handle_cors: If set to False, CORS headers will not be added to
+                            responses. This can be useful if you want to add
+                            CORS headers manually.
+        """
+        self.default_options_handler = app.options_handler
+        if handle_cors:
+            app.options_handler = self.options_handler
+            app.after_request(self.after_request)
+            app.after_error_request(self.after_request)
+
+    def options_handler(self, request):
+        headers = self.default_options_handler(request)
+        headers.update(self.get_cors_headers(request))
+        return headers
+
+    def get_cors_headers(self, request):
+        """Return a dictionary of CORS headers to add to a given request.
+
+        :param request: The request to add CORS headers to.
+        """
+        cors_headers = {}
+        origin = request.headers.get('Origin')
+        if self.allowed_origins == '*':
+            cors_headers['Access-Control-Allow-Origin'] = origin or '*'
+            if origin:
+                cors_headers['Vary'] = 'Origin'
+        elif origin in (self.allowed_origins or []):
+            cors_headers['Access-Control-Allow-Origin'] = origin
+            cors_headers['Vary'] = 'Origin'
+        if self.allow_credentials and \
+                'Access-Control-Allow-Origin' in cors_headers:
+            cors_headers['Access-Control-Allow-Credentials'] = 'true'
+        if self.expose_headers:
+            cors_headers['Access-Control-Expose-Headers'] = \
+                ', '.join(self.expose_headers)
+
+        if request.method == 'OPTIONS':
+            # handle preflight request
+            if self.max_age:
+                cors_headers['Access-Control-Max-Age'] = str(self.max_age)
+
+            method = request.headers.get('Access-Control-Request-Method')
+            if method:
+                method = method.upper()
+                if self.allowed_methods is None or \
+                        method in self.allowed_methods:
+                    cors_headers['Access-Control-Allow-Methods'] = method
+
+            headers = request.headers.get('Access-Control-Request-Headers')
+            if headers:
+                if self.allowed_headers is None:
+                    cors_headers['Access-Control-Allow-Headers'] = headers
+                else:
+                    headers = [h.strip() for h in headers.split(',')]
+                    headers = [h for h in headers
+                               if h.lower() in self.allowed_headers]
+                    cors_headers['Access-Control-Allow-Headers'] = \
+                        ', '.join(headers)
+
+        return cors_headers
+
+    def after_request(self, request, response):
+        saved_vary = response.headers.get('Vary')
+        response.headers.update(self.get_cors_headers(request))
+        if saved_vary and saved_vary != response.headers.get('Vary'):
+            response.headers['Vary'] = (
+                saved_vary + ', ' + response.headers['Vary'])