literalenum 0.1.1__py3-none-any.whl

literalenum/stubgen.py

@@ -0,0 +1,438 @@
+from __future__ import annotations
+
+import argparse
+import ast
+import importlib
+import importlib.util
+import inspect
+import pkgutil
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Iterable
+
+from literalenum import LiteralEnum
+
+
+# ----------------------------
+# Discovery
+# ----------------------------
+
+def _iter_modules(root: str) -> Iterable[str]:
+    pkg = importlib.import_module(root)
+    if not hasattr(pkg, "__path__"):
+        yield root
+        return
+
+    yield root
+    for modinfo in pkgutil.walk_packages(pkg.__path__, pkg.__name__ + "."):
+        yield modinfo.name
+
+
+def _module_origin_py(module: str) -> Path | None:
+    spec = importlib.util.find_spec(module)
+    if not spec or not spec.origin or spec.origin in ("built-in", "namespace"):
+        return None
+    p = Path(spec.origin)
+    return p if p.suffix == ".py" else None
+
+
+def _module_to_adjacent_stub_path(module: str) -> Path | None:
+    origin = _module_origin_py(module)
+    if origin is None:
+        return None
+    if origin.name == "__init__.py":
+        return origin.with_name("__init__.pyi")
+    return origin.with_suffix(".pyi")
+
+
+def _module_to_stub_path(stub_root: Path, module: str) -> Path:
+    rel = Path(*module.split("."))
+    return stub_root / (str(rel) + ".pyi")
+
+
+def _ensure_parent(path: Path) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+
+def _py_literal(v: Any) -> str:
+    # Emit double quotes for strings for nicer stubs.
+    if isinstance(v, str):
+        return '"' + v.replace('"', '\\"') + '"'
+    return repr(v)
+
+
+@dataclass(frozen=True)
+class EnumInfo:
+    module: str
+    name: str
+    qualname: str
+    bases: tuple[type, ...]
+    members: dict[str, Any]  # name -> value (from runtime mapping)
+    call_to_validate: bool = False
+
+
+def _find_literal_enums(root: str) -> list[EnumInfo]:
+    infos: list[EnumInfo] = []
+    for modname in _iter_modules(root):
+        try:
+            mod = importlib.import_module(modname)
+        except Exception:
+            continue
+
+        for _, obj in inspect.getmembers(mod, inspect.isclass):
+            if obj is LiteralEnum:
+                continue
+            if issubclass(obj, LiteralEnum) and obj.__module__ == mod.__name__:
+                members = dict(getattr(obj, "mapping"))
+                infos.append(
+                    EnumInfo(
+                        module=obj.__module__,
+                        name=obj.__name__,
+                        qualname=f"{obj.__module__}.{obj.__name__}",
+                        bases=getattr(obj, "__bases__", ()),
+                        members=members,
+                        call_to_validate=getattr(obj, "_call_to_validate_", False),
+                    )
+                )
+    return infos
+
+
+# ----------------------------
+# Rendering enum stubs
+# ----------------------------
+
+def _render_enum_blocks(enums: list[EnumInfo]) -> str:
+    """
+    Render ONLY enum-related stubs for a module:
+      - <EnumName>T = Literal[...]
+      - class <EnumName>(Base): ...
+    """
+    by_qual = {e.qualname: e for e in enums}
+
+    def _qual_of(cls: type) -> str:
+        return f"{getattr(cls, '__module__', '')}.{getattr(cls, '__name__', '')}"
+
+    def _enum_base_decl(e: EnumInfo) -> str:
+        # If base is another emitted enum in the same module, preserve that inheritance.
+        for b in e.bases:
+            if _qual_of(b) in by_qual:
+                return b.__name__
+        return f"LiteralEnum[{e.name}T]"
+
+    def _inherited_member_names(e: EnumInfo) -> set[str]:
+        names: set[str] = set()
+        for b in e.bases:
+            qb = _qual_of(b)
+            if qb in by_qual:
+                names |= set(by_qual[qb].members.keys())
+        return names
+
+    out: list[str] = []
+    for e in sorted(enums, key=lambda x: x.name):
+        alias = f"{e.name}T"
+        values = list(e.members.values())
+        literal_union = ", ".join(_py_literal(v) for v in values) if values else ""
+        out.append(f"{alias}: TypeAlias = Literal[{literal_union}]\n\n")
+
+        base = _enum_base_decl(e)
+        inherited = _inherited_member_names(e)
+
+        # Only emit new member attributes (avoid duplicating inherited ones).
+        own_members = [(k, v) for (k, v) in e.members.items() if k not in inherited]
+
+        out.append(f"class {e.name}({base}):\n")
+        out.append(f"    T_ = Literal[{literal_union}]\n")
+        if not own_members:
+            out.append("    ...\n")
+        else:
+            for k, v in own_members:
+                out.append(f"    {k}: Final[Literal[{_py_literal(v)}]] = {_py_literal(v)}\n")
+
+        out.append(f"    values: ClassVar[Iterable[{alias}]]\n")
+        out.append(f"    mapping: ClassVar[dict[str, {alias}]]\n\n")
+
+        if e.call_to_validate:
+            out.append("    @overload\n")
+            out.append(f"    def __new__(cls, value: {alias}) -> {alias}: ...\n")
+            out.append("    @overload\n")
+            out.append(f"    def __new__(cls, value: object) -> {alias}: ...\n\n")
+        else:
+            out.append(f"    def __new__(cls, value: Never) -> NoReturn: ...\n\n")
+
+        out.append("    @classmethod\n")
+        out.append(f"    def is_member(cls, value: object) -> TypeGuard[{alias}]: ...\n\n")
+
+    return "".join(out)
+
+
+def stub_for(literalenum_cls: type) -> str:
+    """Return a stub string for a single LiteralEnum class.
+
+    Takes a LiteralEnum subclass at runtime and produces the ``.pyi``
+    content for it — a ``TypeAlias``, a class with ``Final`` members,
+    and typed helper signatures::
+
+        from literalenum import LiteralEnum
+        from literalenum.stubgen import stub_for
+
+        class HttpMethod(LiteralEnum):
+            GET = "GET"
+            POST = "POST"
+
+        print(stub_for(HttpMethod))
+
+    The output is a self-contained snippet (no import header).  Wrap it
+    with your own imports or use the CLI for full-module stubs.
+    """
+    info = EnumInfo(
+        module=getattr(literalenum_cls, "__module__", ""),
+        name=literalenum_cls.__name__,
+        qualname=f"{getattr(literalenum_cls, '__module__', '')}.{literalenum_cls.__name__}",
+        bases=getattr(literalenum_cls, "__bases__", ()),
+        members=dict(getattr(literalenum_cls, "mapping")),
+        call_to_validate=getattr(literalenum_cls, "_call_to_validate_", False),
+    )
+    return _render_enum_blocks([info])
+
+
+def _render_overlay_stub_module(enums: list[EnumInfo]) -> str:
+    """
+    Overlay stub intended for pyright stubPath:
+    only contains the enum stubs (module is "typing overlay").
+    """
+    out: list[str] = []
+    out.append("from __future__ import annotations\n")
+    out.append("from typing import ClassVar, Final, Literal, Iterable, Never, NoReturn, TypeGuard, TypeAlias, overload\n")
+    out.append("from literalenum import LiteralEnum\n\n")
+    out.append(_render_enum_blocks(enums))
+    return "".join(out)
+
+
+# ----------------------------
+# Adjacent stubs (preserve module)
+# ----------------------------
+
+_TYPING_INJECT = "from typing import ClassVar, Final, Literal, Iterable, Never, NoReturn, TypeGuard, TypeAlias, overload"
+_LITERALENUM_INJECT = "from literalenum import LiteralEnum"
+_FUTURE = "from __future__ import annotations"
+
+
+def _read_source(path: Path) -> str:
+    return path.read_text(encoding="utf-8")
+
+
+def _collect_docstring(tree: ast.Module, src: str) -> str | None:
+    if tree.body and isinstance(tree.body[0], ast.Expr) and isinstance(tree.body[0].value, ast.Constant):
+        if isinstance(tree.body[0].value.value, str):
+            seg = ast.get_source_segment(src, tree.body[0])
+            return seg.strip() if seg else None
+    return None
+
+
+def _collect_import_lines(tree: ast.Module, src: str) -> list[str]:
+    lines: list[str] = []
+    for stmt in tree.body:
+        if isinstance(stmt, (ast.Import, ast.ImportFrom)):
+            seg = ast.get_source_segment(src, stmt)
+            if seg:
+                lines.append(seg.strip())
+    return lines
+
+
+def _normalize_imports(import_lines: list[str]) -> list[str]:
+    """
+    Remove imports we will inject exactly once to avoid dupes.
+    """
+    out: list[str] = []
+    for line in import_lines:
+        s = line.strip()
+        if s == _FUTURE:
+            continue
+        if s.startswith("from literalenum import") and "LiteralEnum" in s:
+            continue
+        if s.startswith("from typing import"):
+            # drop any typing line that imports our injected symbols
+            # (simple heuristic: if it mentions any of them, drop it)
+            symbols = ["ClassVar", "Final", "Literal", "Iterable", "TypeGuard", "overload"]
+            if any(sym in s for sym in symbols):
+                continue
+        out.append(s)
+    return out
+
+
+def _is_enum_classdef(stmt: ast.stmt, enum_names: set[str]) -> bool:
+    return isinstance(stmt, ast.ClassDef) and stmt.name in enum_names
+
+
+def _is_safe_preserve_stmt(stmt: ast.stmt) -> bool:
+    """
+    Preserve harmless top-level statements verbatim.
+    - imports handled separately
+    - docstring handled separately
+    """
+    return isinstance(stmt, (ast.Assign, ast.AnnAssign))
+
+
+def _stub_skeleton(stmt: ast.stmt, src: str) -> str | None:
+    # Keep names for everything else, but as stubs.
+    if isinstance(stmt, ast.FunctionDef):
+        header = (ast.get_source_segment(src, stmt) or f"def {stmt.name}(...):").splitlines()[0]
+        if not header.rstrip().endswith(":"):
+            header = header.rstrip() + ":"
+        return header + "\n    ...\n"
+    if isinstance(stmt, ast.AsyncFunctionDef):
+        header = (ast.get_source_segment(src, stmt) or f"async def {stmt.name}(...):").splitlines()[0]
+        if not header.rstrip().endswith(":"):
+            header = header.rstrip() + ":"
+        return header + "\n    ...\n"
+    if isinstance(stmt, ast.ClassDef):
+        # Non-enum class: preserve header with bases, stub body
+        bases = ""
+        if stmt.bases:
+            bases_src = ", ".join(ast.get_source_segment(src, b) or "object" for b in stmt.bases)
+            bases = f"({bases_src})"
+        return f"class {stmt.name}{bases}:\n    ...\n"
+    return None
+
+
+def _render_adjacent_preserving_stub(module: str, enums: list[EnumInfo]) -> str:
+    origin = _module_origin_py(module)
+    if origin is None:
+        return _render_overlay_stub_module(enums)
+
+    src = _read_source(origin)
+    tree = ast.parse(src, filename=str(origin))
+
+    enum_names = {e.name for e in enums}
+
+    doc = _collect_docstring(tree, src)
+    imports = _normalize_imports(_collect_import_lines(tree, src))
+
+    out: list[str] = []
+    out.append(_FUTURE + "\n")
+    if doc:
+        out.append(doc + "\n\n")
+
+    # Original imports (minus ones we inject)
+    if imports:
+        out.extend(line + "\n" for line in imports)
+        out.append("\n")
+
+    # Inject what enum blocks need, exactly once
+    out.append(_TYPING_INJECT + "\n")
+    out.append(_LITERALENUM_INJECT + "\n\n")
+
+    # Walk original statements in order:
+    for stmt in tree.body:
+        # skip docstring/imports (already handled)
+        if stmt is tree.body[0] and doc:
+            continue
+        if isinstance(stmt, (ast.Import, ast.ImportFrom)):
+            continue
+
+        # Replace enum classdefs with generated blocks later; skip here.
+        if _is_enum_classdef(stmt, enum_names):
+            continue
+
+        # Preserve simple assignments verbatim
+        if _is_safe_preserve_stmt(stmt):
+            seg = ast.get_source_segment(src, stmt)
+            if seg:
+                out.append(seg.strip() + "\n\n")
+            continue
+
+        # For everything else, emit skeleton stubs so names remain
+        sk = _stub_skeleton(stmt, src)
+        if sk:
+            out.append(sk + "\n")
+            continue
+
+        # Drop other statements (loops, runtime code, etc.)—not valid/meaningful in stubs.
+
+    # Now append enum stubs (aliases + class stubs)
+    out.append(_render_enum_blocks(enums))
+
+    return "".join(out)
+
+
+# ----------------------------
+# CLI
+# ----------------------------
+
+def _parse_out_args(raw: list[str] | None) -> list[Path]:
+    """
+    Supports:
+      --out typings
+      --out typings --out stubs
+      --out "typings,stubs"
+      --out "typings;stubs"
+    """
+    if not raw:
+        return [Path("typings")]
+    out: list[Path] = []
+    for item in raw:
+        parts = [p.strip() for p in item.replace(";", ",").split(",") if p.strip()]
+        out.extend(Path(p) for p in parts)
+
+    # de-dupe while preserving order
+    seen: set[Path] = set()
+    uniq: list[Path] = []
+    for p in out:
+        if p not in seen:
+            seen.add(p)
+            uniq.append(p)
+    return uniq
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("root", help="Root import (package or module) to scan, e.g. myapp")
+    ap.add_argument(
+        "--out",
+        action="append",
+        help="Also write overlay stubs to this directory (e.g. typings). "
+             "Repeatable or comma/semicolon-separated.",
+    )
+    ap.add_argument(
+        "--no-adjacent",
+        action="store_true",
+        help="Skip writing module.pyi next to module.py.",
+    )
+    args = ap.parse_args()
+
+    write_adjacent: bool = not args.no_adjacent
+    out_roots: list[Path] = _parse_out_args(args.out) if args.out else []
+    infos = _find_literal_enums(args.root)
+
+    by_module: dict[str, list[EnumInfo]] = {}
+    for e in infos:
+        by_module.setdefault(e.module, []).append(e)
+
+    written = 0
+    for module, enums in by_module.items():
+        # Adjacent stubs (module.pyi next to module.py) — default
+        if write_adjacent:
+            adjacent_text = _render_adjacent_preserving_stub(module, enums)
+            adj_path = _module_to_adjacent_stub_path(module)
+            if adj_path is not None:
+                _ensure_parent(adj_path)
+                adj_path.write_text(adjacent_text, encoding="utf-8")
+                written += 1
+
+        # Overlay stubs (e.g. typings/) — only when --out is given
+        if out_roots:
+            overlay_text = _render_overlay_stub_module(enums)
+            for stub_root in out_roots:
+                out_path = _module_to_stub_path(stub_root, module)
+                _ensure_parent(out_path)
+                out_path.write_text(overlay_text, encoding="utf-8")
+                written += 1
+
+    print(f"Wrote {written} stub file(s) for {len(infos)} LiteralEnum subclasses.")
+    return 0
+
+
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

literalenum-0.1.1.dist-info/METADATA

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: literalenum
+Version: 0.1.1
+Summary: A Python typing construct that provides namespaced literal constants with advanced typing features.
+Project-URL: Homepage, https://github.com/modularizer/literalenum
+Project-URL: Repository, https://github.com/modularizer/literalenum
+Project-URL: Issues, https://github.com/modularizer/literalenum/issues
+Author-email: Torin Halsted <modularizer@gmail.com>
+License: Unlicense
+License-File: LICENSE
+Keywords: python,typehinting
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# LiteralEnum
+
+**LiteralEnum** is an experiment/prototype for a proposed Python typing construct: 
+a *finite, named set of runtime literals* (usually strings) that type checkers can treat as 
+an **exhaustive `Literal[...]` union**.
+
+> Status: Prototype / exploration for typing-sig discussion. Not an accepted PEP.
+
+## Why this exists
+In typed Python today you often have to pick one:
+
+- `Enum` / `StrEnum`: great runtime namespace, but APIs want callers to pass enum members instead of raw strings
+- `Literal[...]`: great static checking, but no runtime namespace/iteration/validation
+
+So people duplicate values or accept `str` and validate at runtime.
+
+LiteralEnum aims to make the common case a single source of truth.
+
+It’s designed for “protocol token” style values—HTTP methods, event names, command identifiers, config keys—where you want:
+- **plain literals at runtime** (e.g. `"GET"`),
+- **namespaced constants** (e.g. `HttpMethod.GET`), and
+- **static exhaustiveness checking** (i.e. the type is equivalent to `Literal["GET", "POST", ...]`).
+
+---
+## Table of Contents
+- [Typing discussion](https://discuss.python.org/t/proposal-literalenum-runtime-literals-with-static-exhaustiveness/106000) with the Python community
+- [PEP.md](/PEP.md) is a draft PEP
+- [LITMUS.md](/LITMUS.md) describes the project goals
+- [TYPING_DISCUSSION.md](/TYPING_DISCUSSION.md) is shows drafts from the discussion
+- [src/typing_literalenum.py](/src/typing_literalenum.py) is a the draft of the core runtime functionality (proposed to become `typing.LiteralEnum` or `typing_extensions.LiteralEnum`)
+- [src/literalenum](/src/literalenum) is the full proposed PyPi module
+- [src/literalenum/mypy_plugin.py](/src/literalenum/mypy_plugin.py) is an experimental **mypy plugin**
+- [src/literalenum/samples](/src/literalenum/samples) shows sample usage
+- [src/literalenum/stubgen.py](/src/literalenum/stubgen.py) provides tools for generating stubs, usable through CLI tool `lestub`
+
+---
+
+## Quickstart
+
+## Install
+
+This repo is currently set up as a package under `src/`.
+
+```bash
+#python -m venv .venv
+#source .venv/bin/activate
+pip install literalenum
+```
+
+```python
+from literalenum import LiteralEnum
+
+class HttpMethod(LiteralEnum):
+    GET = "GET"
+    POST = "POST"
+    DELETE = "DELETE"
+
+def handle(method: HttpMethod) -> None:
+    print(f"{method=}")
+
+handle("GET")          # ✅ should type-check
+handle(HttpMethod.GET) # ✅ should type-check
+handle("git")          # ❌ should be rejected by a type checker
+
+assert HttpMethod.GET == "GET"
+assert list(HttpMethod) == ["GET", "POST", "DELETE"]
+assert "GET" in HttpMethod
+print(HttpMethod.keys())
+print(HttpMethod.values())
+print(HttpMethod.mapping)
+```
+
+---
+
+## Contributing / discussion
+
+Actively looking for feedback!
+Please comment at https://discuss.python.org/t/proposal-literalenum-runtime-literals-with-static-exhaustiveness/106000
+
+It would be especially helpful if you are familiar with mypy/pright/pylance and have suggestions on how
+a future Python version could support the type hinting goals.
+
+---
+
+## License
+
+This project is released into the **public domain** under **The Unlicense**.
+
+You are free to copy, modify, publish, use, compile, sell, or distribute this software,
+either in source code form or as a compiled binary, for any purpose, commercial or non-commercial,
+and by any means.
+
+See the `LICENSE` file for full details.
+

literalenum-0.1.1.dist-info/RECORD

@@ -0,0 +1,27 @@
+literalenum/__init__.py,sha256=Cle3alhK2TPqkjKZ6yEFB3_2yv-y0EwtdYUnbkRG_-s,477
+literalenum/literal_enum.py,sha256=OfB73GCHeZ5G1cAz3EA99zzZsmQ6jtL3xx3AKK-XP-0,3907
+literalenum/mypy_plugin.py,sha256=JExHoi8NP_QJI0eESRed3TdR3DxEVrj7qA6q-bhj3KU,11020
+literalenum/stubgen.py,sha256=U-Ch7-KyAoJXMmGFW5sLRNNszYnMd0T_3mjXHtAOWEo,14456
+literalenum/compatibility_extensions/__init__.py,sha256=nIY32idsLpo9VyXtDREWMzLAfYUU7K7Zm3Cl69mWR0k,551
+literalenum/compatibility_extensions/annotated.py,sha256=68TxWaCzMdcuFgnyWfWHUtzUClP5r99BMydSufdgcRA,146
+literalenum/compatibility_extensions/bare_class.py,sha256=LXhT5BfIBJmfA8ZQmHfAVyF4IpM9911oUcj4xtonLFM,75
+literalenum/compatibility_extensions/base_model.py,sha256=3-QWUnGLhL9R5-bEW8xpsRMaTo3tdLE7Lqmwnm8xmMg,667
+literalenum/compatibility_extensions/click_choice.py,sha256=oaceRBUDXeOOpRkil-9R2pfBQCF7F5BN_G_x-s4VNeY,74
+literalenum/compatibility_extensions/django_choices.py,sha256=hZVrZLhbmpHL5g12xlzKBbErQXLZjwOImfwCrumCrCQ,75
+literalenum/compatibility_extensions/enum.py,sha256=VvWsWab8gjNKsNCGoBFr-Mj_fSWCY7ZHjUqwbZ1WGro,154
+literalenum/compatibility_extensions/graphene_enum.py,sha256=cwovO1C82YxXXk1kRacZKGJKj44loYSFa_1jKgUiRY4,522
+literalenum/compatibility_extensions/int_enum.py,sha256=JNs3BYZdnLxkcR7JaqSGwtr-01Wqfec8b6XUd2-JuSg,326
+literalenum/compatibility_extensions/json_schema.py,sha256=hnIk8ACNXO3jqw1qu0RaVZPXvUGIBFTjwA4ish4tc3g,5197
+literalenum/compatibility_extensions/literal.py,sha256=3R25lT4mlUzRdICgjjGyTdQy87PdbiwdWEP9sKUUPOc,223
+literalenum/compatibility_extensions/random_choice.py,sha256=49-oSH6ebQJv0GIcYMDq_N9piI2kRG0RCY9bvWt7Q_s,88
+literalenum/compatibility_extensions/regex.py,sha256=4XDtC8VlehMlcZkcE5L9nXbKkR4w2MXk411Q0OdfCyw,441
+literalenum/compatibility_extensions/sqlalchemy_enum.py,sha256=DF_ce3Q7YNp98mTFXPsyWagQVzTTaczI-dRklOPh_LY,237
+literalenum/compatibility_extensions/str_enum.py,sha256=y-VWFyaEDXmNicgyqzdEpsx-ImUdnydbF_YWhzvEVq0,329
+literalenum/compatibility_extensions/strawberry_enum.py,sha256=mjg3Pyy0w_AggRRB_UtuWQiOguiG66eTN5E_rpwd7cg,526
+typing_literalenum.py,sha256=ZoM0rbr-7Hp72uqohJ6enm-eIhUwAHTGBsb-FsQmXJs,24837
+literalenum/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+literalenum-0.1.1.dist-info/METADATA,sha256=ZO4NgWWrqRpFZgexLjkyMX5wBVYmn2UMfS5KSdfXuiA,3957
+literalenum-0.1.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+literalenum-0.1.1.dist-info/entry_points.txt,sha256=AK8je10LoLMOXuWLjXSqHV2rsTxPW9HlG7YTJGfwkCY,46
+literalenum-0.1.1.dist-info/licenses/LICENSE,sha256=tQZYOMusRS38hVum5uAxSBrSxoQG9w0h6tkyE3RlPmw,1212
+literalenum-0.1.1.dist-info/RECORD,,

literalenum-0.1.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

literalenum-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+lestub = literalenum:lestub

literalenum-0.1.1.dist-info/licenses/LICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <https://unlicense.org/>