molty 0.1.0__tar.gz

molty-0.1.0/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

molty-0.1.0/MANIFEST.in

@@ -0,0 +1 @@
+recursive-include tests *.py

molty-0.1.0/PKG-INFO

@@ -0,0 +1,371 @@
+Metadata-Version: 2.4
+Name: molty
+Version: 0.1.0
+Summary: A strict superset of Python that turns common Python traps into compile-time errors.
+Author: Shogo Toda
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/Shogo256/molty
+Project-URL: Repository, https://github.com/Shogo256/molty
+Project-URL: Issues, https://github.com/Shogo256/molty/issues
+Keywords: python,superset,transpiler,immutability,concurrency,asyncio,multiprocessing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Compilers
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+```text
+ __  __  ___  _   _______   __
+|  \/  |/ _ \| | |_   _\ \ / /
+| |\/| | | | | |   | |  \ V /
+| |  | | |_| | |___| |   | |
+|_|  |_|\___/|_____|_|   |_|
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~:>   Molty
+```
+
+# Molty
+
+Molty is a strict superset of Python. Every valid Python file is a valid
+Molty file. Molty adds a few keywords that turn everyday Python traps into
+errors at compile time: shared mutable objects, the wrong kind of
+concurrency, and type hints that protect nothing at run time.
+
+`moltyc` compiles `app.molty.py` to a plain, readable `app.py` that imports only
+`molty.runtime`. Ordinary type checking is left to mypy and pyright, run on the
+generated file.
+
+## The trap, side by side
+
+The same file, run as plain Python and compiled by moltyc:
+
+```text
+# plain Python                            # Molty
+def add(item, items: list = []):          def add(item, items: list = []):
+    items.append(item)                        items.append(item)
+    return items                              return items
+
+print(add(1))  # [1]                      $ moltyc app.molty.py
+print(add(2))  # [1, 2]  <- same list     app.molty.py:1:29: warning MOL1004:
+print(add(3))  # [1, 2, 3]                  default [] of 'items' is created
+                                            once and shared by every call
+# nothing tells you                       # moltyc tells you before it runs
+```
+
+By default moltyc does not change what the code means. The `.py` it writes
+behaves exactly like the source, and the warning tells you about the trap.
+There are two ways to act on it:
+
+```python
+def lookup(key, _cache={}):  # molty: cache
+    ...                      # the sharing is on purpose: no warning
+```
+
+```bash
+moltyc --rewrite-defaults app.molty.py   # moltyc gives every call a fresh list
+```
+
+`--rewrite-defaults` changes the meaning on purpose, and in one way only:
+every call gets a fresh object. With it, moltyc writes:
+
+```python
+def add(item, items: list | None = None):
+    if items is None:  # molty: fresh default on every call
+        items = []
+    items.append(item)
+    return items
+```
+
+## A superset, checked
+
+Every `.py` file in the standard library compiles under moltyc without errors.
+Each one comes out byte for byte the same, apart from the one-line
+generated-file header. We checked 628 files on CPython 3.14 (Ubuntu), and 633,
+686 and 734 files on 3.13, 3.12 and 3.11 (python-build-standalone). To check
+it on your own Python:
+
+```bash
+MOLTY_STDLIB=1 python -m unittest discover -s tests -p test_stdlib_superset.py
+```
+
+## Install and run
+
+Not on PyPI yet. From a checkout:
+
+```bash
+pip install -e .
+```
+
+```bash
+moltyc app.molty.py              # writes app.py next to it
+moltyc src/                    # every *.molty.py under src/
+moltyc app.molty.py -o -         # print to stdout
+moltyc app.molty.py --explain    # list every rewrite moltyc made
+moltyc app.molty.py --rewrite-defaults   # fix mutable defaults instead of warning
+moltyc app.molty.py -q           # no success line
+moltyc app.molty.py --force      # overwrite an app.py that moltyc did not write
+moltyc --version
+```
+
+`moltyc` exits with 1 if any file has errors. Warnings are printed, but the
+`.py` file is still written. At a terminal, each file that compiles gets one
+line on stderr:
+
+```text
+~~~~:>  app.molty.py -> app.py  ok (2 warnings)
+```
+
+When the output is piped, as in CI, that line is left out, and
+`moltyc --version` prints a plain `moltyc 0.1.0` instead of the logo.
+
+moltyc refuses to write a `.py` file, and exits with 1, in these cases:
+
+* the file is a symbolic link
+* the file is one of the sources, as with `-o app.molty.py`
+* the file is an existing regular file that moltyc did not generate (`--force`
+  overwrites it); `-o /dev/null`, to see only the diagnostics, is fine
+
+When moltyc walks a directory, it skips symbolic links, so it never reads
+files outside the tree. A file named on the command line is read even if it
+is a link.
+
+moltyc also opens the file with `O_NOFOLLOW`, so a link put in place after the
+checks above cannot redirect the write either. Windows has no `O_NOFOLLOW`;
+there, the check before writing is the only guard.
+
+## What Molty adds
+
+### `val` and `var`
+
+```python
+val config = {"host": "localhost", "ports": [8080, 8081]}
+var count = 0
+```
+
+* A `val` can never be rebound in its scope (MOL1001). That covers `=`,
+  `+=`, `for`, `with ... as`, `import`, `del`, `global` and `nonlocal`.
+* A `val` may be declared once in each branch of an `if`/`elif`/`else` or a
+  `match`, since only one of them runs:
+
+  ```python
+  if verbose:
+      val LEVEL = "debug"
+  else:
+      val LEVEL = "info"
+  ```
+* Literals bound to a `val` are frozen at compile time, nested ones
+  included: `list` becomes `tuple`, `dict` becomes `MappingProxyType`,
+  `set` becomes `frozenset`. The annotation follows, so
+  `val xs: list[int] = [1]` becomes `xs: tuple[int, ...] = (1,)`.
+* Changing a frozen `val` in place, as in `PRICES.append(3)` or
+  `CONFIG["port"] = 80`, is an error (MOL1005); it would fail at run time
+  anyway. So is changing a frozen part of it, as in `CONFIG["db"]["host"] = "y"`,
+  and `ROUTES[key].append(x)` when every item of `ROUTES` is a frozen literal.
+  A value you build up step by step belongs in a `var`.
+* A `val` bound to any other object, such as `val cache = LRUCache()`, only
+  promises not to be rebound. Its methods can be called as usual.
+* `json.dumps` does not accept a frozen dict. Convert it first:
+  `json.dumps(dict(config))`.
+* `var` and plain `x = ...` work exactly as in Python.
+
+### `val` parameters
+
+```python
+def total(items: val list[int]) -> int:
+    items.append(0)    # MOL1002
+    return sum(items)
+```
+
+Rebinding a `val` parameter, or calling one of the built-in mutating methods
+of `list`, `dict` and `set` on it (`append`, `update`, `items[k] = v`, `+=`,
+...), is an error. The full list is `MUTATING_METHODS` in
+`molty/compiler/rules.py`. Callers pass the object as usual; nothing is copied.
+
+Because the function promises not to change the argument, moltyc widens its
+annotation to the read-only type: `list[int]` becomes `Sequence[int]`,
+`dict[K, V]` becomes `Mapping[K, V]`, and `set[T]` becomes `AbstractSet[T]`.
+Frozen `val` values (a tuple, a `MappingProxyType`, a `frozenset`) can then be
+passed in, and both `@molty.checked` and mypy accept them.
+
+### Mutable default arguments
+
+A `list`, `dict` or `set` literal, or a call such as `list()` or
+`collections.defaultdict(...)`, used as a default is a MOL1004 warning. The
+code is left alone.
+
+* A `# molty: cache` comment on the parameter's line marks the sharing as
+  intended. The warning goes away, and the parameter is never rewritten.
+* `moltyc --rewrite-defaults` rewrites each unmarked default to a `None`
+  default plus a check in the body, as shown above. `--explain` lists every
+  rewrite.
+* It only moves a default whose names are builtins, module-level imports, or
+  the loop variables of a comprehension inside the default. Any other name
+  would mean something else in the function body: a class attribute is not
+  visible there, and a variable would be read at call time instead of when
+  `def` ran. Such a default keeps the warning, and so does a default of a
+  `lambda`.
+
+### `task`, `compute` and `scope`
+
+```python
+task def fetch(url: str) -> bytes: ...        # I/O-bound: an asyncio coroutine
+compute def digest(data: bytes) -> bytes: ... # CPU-bound: runs in a process pool
+
+task def main(urls: list[str]) -> list[bytes]:
+    async with scope() as s:
+        for url in urls:
+            s.spawn(fetch(url))
+    pages = s.results()                   # everything spawned has finished here
+    return [await digest(page) for page in pages]
+```
+
+* `task def` compiles to `async def`.
+* Calling a `compute` function returns a coroutine that runs the body in a
+  shared `ProcessPoolExecutor`, so you can `await` it or `spawn` it.
+* `scope()` wraps `asyncio.TaskGroup`. `s.results()` returns the results in
+  spawn order once the block has exited. If one spawned task fails, the
+  others are cancelled, the block raises an `ExceptionGroup`, and
+  `s.results()` is no longer usable. Partial results have to be collected by
+  the tasks themselves.
+* A `compute` that calls a `task` is an error (MOL2001). A `task` that awaits
+  a `compute` is fine.
+* A call to a `task` or `compute` whose coroutine never gets run is a warning
+  (MOL2006). That covers using the result in an f-string or an expression,
+  dropping it, and passing it to an ordinary function such as `print(work(n))`.
+  Awaiting it, assigning it, returning it, and passing it to something that
+  runs coroutines (`s.spawn`, `asyncio.run`, `asyncio.gather`,
+  `asyncio.wait_for`, `create_task`, `run_until_complete`, ...) are fine; to
+  hand it to a helper of your own, assign it to a name first. A `compute`
+  calling another `compute` is also MOL2006, because a worker process cannot
+  await. The check covers functions defined in the same file, called by their
+  own name or through a plain alias such as `f = work`.
+* A job that calls `sys.exit()`, or raises an exception the caller cannot
+  rebuild (one whose `__init__` takes two arguments, say), fails with
+  `molty.runtime.ComputeError` instead. Its message names the original
+  exception, and the worker's traceback comes with it. Other jobs are not
+  affected, and the caller's program keeps running.
+* If a worker process dies (a crash, `os._exit`, running out of memory), the
+  calls in flight fail with `BrokenProcessPool`. The next call starts a fresh
+  pool. A failed call is not retried, since it may be the one that crashed.
+* Cancelling a `compute` call, or letting it time out (`asyncio.wait_for`, a
+  failing scope), stops the waiting but not the work. The job runs to the end
+  and keeps its worker busy, so later `compute` calls can queue behind jobs
+  nobody is waiting for any more.
+* For long jobs that must really stop, put `@molty.isolated` on the
+  `compute def`. Each call then runs in a process of its own, and cancelling
+  or timing out the call kills that process at once, without touching any
+  other call. Starting the process costs about 10 ms per call on Linux
+  (forkserver) and about 170 ms where only spawn exists, as on Windows. At
+  most as many isolated calls run at once as there are CPUs. `@molty.isolated`
+  on anything other than a `compute def` is an error (MOL2007).
+
+  ```python
+  import molty
+
+  @molty.isolated
+  compute def render(job: Job) -> bytes: ...
+  ```
+* Arguments and the result of a `compute` must pickle. Types that are
+  picklable by their hint (`int`, `str`, `bytes`, containers of them with the
+  item types written out, enums, and module-level dataclasses, NamedTuples and
+  TypedDicts) are accepted at compile time with no run-time cost. A bare
+  `dict` or `list` says nothing about its items, so it is checked at run time. Types that never pickle (`threading.Lock`,
+  generators, sockets, ...) are an error (MOL2004). Anything else is checked
+  when the call is made, and the result is checked in the worker.
+* Stopped with SIGTERM (the default of `kill`, systemd and Docker), Python
+  skips its exit handlers, so the forkserver and idle workers stay behind.
+  Turn SIGTERM into a normal exit when the program starts; Ctrl-C needs
+  nothing.
+
+  ```python
+  import signal, sys
+  signal.signal(signal.SIGTERM, lambda *_: sys.exit(0))
+  ```
+* A `compute def` must be a plain module-level function (MOL2005), because
+  worker processes import it by name. As with any `multiprocessing` code,
+  start your program under `if __name__ == "__main__":`, and run it from a
+  file. Code fed through stdin or a REPL fails with confusing errors, because
+  the workers cannot import the main module.
+* Creating a `threading.Thread` inside a `task` or `compute` is a warning
+  (MOL2002), and so is `asyncio.create_task` outside a scope (MOL2003).
+  Neither is forbidden.
+
+### `@molty.checked`
+
+```python
+import molty
+
+@molty.checked
+def scale(xs: list[int], factor: float) -> list[float]: ...
+
+scale("abc", 2)   # CheckError: scale() argument 'xs' must be list, not str
+```
+
+Only functions with the decorator are checked. By default the check covers
+the arguments only and is shallow: `list[int]` checks for `list` but not its
+elements. Two options go further, at the cost of more work on every call:
+
+```python
+@molty.checked(deep=True)      # items of lists, tuples, sets and dicts too
+def load(rows: list[dict[str, int]]) -> None: ...
+# CheckError: load() argument 'rows'[2]['id'] must be int, not str
+
+@molty.checked(returns=True)   # the return value too
+def name() -> str: ...
+```
+
+The check follows `isinstance`, as mypy does, so `True` passes where an
+`int` is expected, and an `int` passes where a `float` is.
+
+### `MOLTY_CHECKS=0`
+
+This turns off every run-time check: `@molty.checked` returns the function
+unchanged, and `compute` stops checking picklability.
+
+## Diagnostics
+
+| Code    | Kind    | Meaning                                                      |
+|---------|---------|--------------------------------------------------------------|
+| MOL0001 | error   | syntax error                                                 |
+| MOL1001 | error   | a `val` is rebound                                           |
+| MOL1002 | error   | a `val` parameter is rebound or mutated                      |
+| MOL1003 | error   | malformed `val`/`var` declaration (`val x: int` with no value, `val a.b = 1`, ...) |
+| MOL1004 | warning | a mutable default argument, shared by every call             |
+| MOL1005 | error   | a frozen `val` is changed in place                           |
+| MOL2001 | error   | a `compute` calls a `task`                                   |
+| MOL2002 | warning | `threading.Thread` inside a `task` or `compute`              |
+| MOL2003 | warning | `asyncio.create_task` outside `scope()`                      |
+| MOL2004 | error   | a `compute` argument or result cannot be pickled             |
+| MOL2005 | error   | a `compute def` that is nested, a method, or a generator     |
+| MOL2006 | warning | a `task` or `compute` called but not awaited or handed on    |
+| MOL2007 | error   | `@molty.isolated` on something other than a `compute def`      |
+
+## Limits of this first version
+
+* There is no ownership model. Aliasing a `val` parameter (`other = items;
+  other.append(1)`) is not caught.
+* Tested on CPython 3.11, 3.12, 3.13 and 3.14. On 3.11, a `@molty.checked`
+  task is checked when it is awaited rather than when it is called, because
+  `inspect.markcoroutinefunction` only exists from 3.12.
+
+## Development
+
+```bash
+python -m unittest discover -s tests
+```
+
+The package and the tests use only the standard library. The `molty` package
+passes `mypy --strict`.
+
+## License
+
+Apache License 2.0. See [LICENSE](LICENSE).