git-repokit 0.9.10__py3-none-any.whl

repokit/layers.py

@@ -0,0 +1,510 @@
+"""Code-type template layers: the second of git-repokit's two template systems.
+
+The structure system (repo_manager._generate_template_files) writes the files
+every project gets, from *.template files with $var placeholders. This module
+lays the code type on top: a manifest-driven walk over layer folders under
+repokit/templates/layers/ -- a language's layer, then an archetype's -- where
+a later file replaces an earlier one, a file named <name>.rkappend is appended
+to <name> (including a file the structure system already wrote), __RK_NAME__
+tokens are replaced in file names and text contents, and workflow files are
+copied byte for byte (a token inside one is an error, because GitHub Actions'
+own ${{ }} lives there). Both systems render through one TemplateEngine and
+one context (template_engine.token_context), so a project has one set of names.
+
+Ported from the proof in git-repokit-common,
+tests/one-offs/thinking/poc-templates-c-cpp/assemble.py (8/8 arms on
+2026-10-07); design: the Phase 2 v2 analysis of 2026-10-09 in the vault.
+
+The manifest (repokit/templates/layers/manifest.toml):
+
+    [languages.python]
+    layers = ["languages/python"]
+    default = "python/setuppy"          # the archetype a bare --language gets
+
+    [languages.javascript]
+    stub = true                         # named, announced, not built yet
+    description = "planned as the js-ts layer"
+
+    [archetypes."python/setuppy"]
+    languages = ["python"]              # implied when --archetype names it
+    layers = ["archetypes/python/setuppy"]
+    description = "setup.py and requirements.txt (git-repokit's output before 0.7)"
+"""
+
+import difflib
+import os
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+from .template_engine import TemplateEngine, RK_TOKEN
+
+MANIFEST = "manifest.toml"
+APPEND = ".rkappend"
+WORKFLOWS = ".github/workflows/"
+GENERIC = "generic"          # no code-type layers at all
+LAYERS_DIR = "layers"        # under the templates directory
+ARCHETYPES_DIR = "archetypes"
+NOT_A_PRESET = "assembled from layers; not a tested preset"
+UNRANKED = 99                # a layer folder with no [layers] entry sorts last, in the order given
+# Files only the primary language writes in a multi-language project (0.9.2):
+# VS Code reads one of each, and merging two languages' JSON is out of scope.
+PRIMARY_ONLY = (".vscode/launch.json", ".vscode/tasks.json")
+
+
+class LayerError(Exception):
+    """A language or archetype that cannot be assembled: unknown, a stub, or a
+    broken layer tree. The message is for the person; create stops before
+    `git init` when it is raised."""
+
+
+@dataclass
+class Resolution:
+    layers: List[str] = field(default_factory=list)       # layer folders in apply order
+    languages: List[str] = field(default_factory=list)
+    archetype: Optional[str] = None                       # the preset the request equals, or None
+    tokens: List[str] = field(default_factory=list)       # what --with asked for, as given
+    names: List[str] = field(default_factory=list)        # qualified layer names in apply order
+    notes: List[str] = field(default_factory=list)        # e.g. NOT_A_PRESET
+
+
+def _load_toml(path: Path) -> Dict[str, Any]:
+    try:
+        import tomllib
+    except ImportError:  # Python < 3.11
+        try:
+            import tomli as tomllib  # type: ignore
+        except ImportError:
+            raise LayerError(f"{path} needs a TOML parser: Python 3.11+ or the tomli package") from None
+    try:
+        with open(path, "rb") as f:
+            return tomllib.load(f)
+    except (tomllib.TOMLDecodeError, OSError) as e:
+        raise LayerError(f"cannot read {path}: {e}") from None
+
+
+def layers_root(engine: Optional[TemplateEngine] = None) -> Optional[Path]:
+    """The layers folder of the templates directory the engine found, or None."""
+    engine = engine or TemplateEngine()
+    if not engine.templates_dir:
+        return None
+    root = Path(engine.templates_dir) / LAYERS_DIR
+    return root if (root / MANIFEST).is_file() else None
+
+
+def load_manifest(root: Path) -> Dict[str, Any]:
+    data = _load_toml(root / MANIFEST)
+    data.setdefault("languages", {})
+    data.setdefault("archetypes", {})
+    data.setdefault("layers", {})
+    data.setdefault("facets", {})
+    return data
+
+
+def known_languages(manifest: Dict[str, Any]) -> List[str]:
+    """Every language the manifest names (stubs included), plus generic. A
+    pseudo-language (`pseudo = true`, such as `any`, which holds layer files
+    shared by several languages) is not a language a project can have."""
+    return [GENERIC] + sorted(k for k, v in manifest["languages"].items() if not v.get("pseudo"))
+
+
+def is_pseudo(manifest: Dict[str, Any], name: str) -> bool:
+    return bool(manifest["languages"].get(name, {}).get("pseudo"))
+
+
+def known_archetypes(manifest: Dict[str, Any]) -> List[str]:
+    """The presets: what --with <lang>/<name> expands to."""
+    return sorted(manifest["archetypes"])
+
+
+def known_layers(manifest: Dict[str, Any]) -> List[str]:
+    """Every [layers] entry, qualified (stubs included)."""
+    return sorted(manifest["layers"])
+
+
+def layer_folder(manifest: Dict[str, Any], key: str) -> str:
+    """The folder a [layers] entry stands for: archetypes/<lang>/<name>, by convention."""
+    return f"{ARCHETYPES_DIR}/{key}"
+
+
+def facet_rank(manifest: Dict[str, Any], facet: Optional[str]) -> int:
+    f = manifest["facets"].get(facet or "", {})
+    return f.get("rank", UNRANKED)
+
+
+def facet_exclusive(manifest: Dict[str, Any], facet: Optional[str]) -> bool:
+    return bool(manifest["facets"].get(facet or "", {}).get("exclusive", False))
+
+
+def parse_languages(value) -> List[str]:
+    """A list, or a comma-separated string, or a list of either -> names in
+    the order given, without repeats or blanks."""
+    items: List[str] = []
+    for part in (value if isinstance(value, (list, tuple)) else [value or ""]):
+        for name in str(part).split(","):
+            name = name.strip()
+            if name and name not in items:
+                items.append(name)
+    return items
+
+
+def _suggest(token: str, choices: List[str]) -> str:
+    close = difflib.get_close_matches(token, choices, n=3, cutoff=0.6)
+    return f"; did you mean {', '.join(close)}?" if close else ""
+
+
+def _check_language(manifest: Dict[str, Any], name: str) -> None:
+    entry = manifest["languages"].get(name)
+    if entry is None:
+        raise LayerError(f"unknown language {name!r}; known: {', '.join(known_languages(manifest))}")
+    if entry.get("stub"):
+        raise LayerError(f"language {name} is not built yet: {entry.get('description', '')}".rstrip(": "))
+
+
+def _preset_layers(manifest: Dict[str, Any], key: str) -> List[Tuple[str, Optional[str]]]:
+    """A preset's (folder, qualified layer name or None) pairs, after the stub check."""
+    preset = manifest["archetypes"][key]
+    if preset.get("stub"):
+        raise LayerError(f"archetype {key} is not built yet: {preset.get('description', '')}".rstrip(": "))
+    out = []
+    for folder in preset.get("layers", []):
+        name = folder[len(ARCHETYPES_DIR) + 1:] if folder.startswith(ARCHETYPES_DIR + "/") else None
+        out.append((folder, name if name in manifest["layers"] else None))
+    return out
+
+
+def _layer(manifest: Dict[str, Any], key: str) -> Tuple[str, str]:
+    entry = manifest["layers"][key]
+    if entry.get("stub"):
+        raise LayerError(f"layer {key} is not built yet: {entry.get('description', '')}".rstrip(": "))
+    return layer_folder(manifest, key), key
+
+
+def resolve(manifest: Dict[str, Any], languages, with_tokens=None, _recognise: bool = True) -> Resolution:
+    """The ordered layers for these languages and these --with tokens.
+
+    The eight rules (Phase 3 design, D2): tokens are split on commas and
+    lower-cased; a preset (an [archetypes] key) expands to its layers; a bare
+    name is looked up across layers and presets, narrowed by the languages
+    listed or already implied, and refused with every qualified form when it
+    stays ambiguous; every layer implies its language and whatever its entry
+    `implies`, transitively; two layers in one exclusive facet of one language
+    are refused naming the pair and the facet; layers are ordered by facet
+    rank, then by the order given, after the languages' own layers; a list
+    that equals a preset's expansion is reported as that preset, any other
+    list carries the NOT_A_PRESET note; with no tokens the FIRST language's
+    default preset applies (the first language is the project's primary one);
+    stubs refuse with their description; an unknown name suggests close ones.
+    generic means no layers.
+    """
+    table = manifest["languages"]
+    presets = manifest["archetypes"]
+    layer_table = manifest["layers"]
+    langs = [name for name in parse_languages(languages) if name != GENERIC]
+    tokens: List[str] = []
+    for t in parse_languages(with_tokens):
+        if t.lower() not in tokens:
+            tokens.append(t.lower())
+    for name in langs:
+        _check_language(manifest, name)
+        if is_pseudo(manifest, name):
+            raise LayerError(f"{name!r} holds layers shared by several languages; it is not a project language")
+    res = Resolution(languages=langs, tokens=list(tokens))
+
+    chosen: List[Tuple[str, Optional[str]]] = []      # (folder, qualified name or None), in the order given
+    presets_used: List[str] = []
+
+    def add_language(name: str) -> None:
+        if name not in langs:
+            _check_language(manifest, name)
+            if is_pseudo(manifest, name):
+                return          # a shared layer's folder prefix, never a project language
+            langs.append(name)
+
+    def add_preset(key: str) -> None:
+        presets_used.append(key)
+        for lang_name in presets[key].get("languages", []) or [key.split("/")[0]]:
+            add_language(lang_name)
+        for pair in _preset_layers(manifest, key):
+            if pair not in chosen:
+                chosen.append(pair)
+
+    def add_layer(key: str) -> None:
+        pair = _layer(manifest, key)
+        add_language(key.split("/")[0])
+        if pair not in chosen:
+            chosen.append(pair)
+
+    # Pass 1: presets and qualified names; bare names that are unique anywhere.
+    # Pass 2: the bare names left, narrowed by the languages now known.
+    deferred: List[str] = []
+    for tok in tokens:
+        if tok in presets:
+            add_preset(tok)
+        elif "/" in tok:
+            if tok in layer_table:
+                add_layer(tok)
+            else:
+                known = sorted(set(presets) | set(layer_table))
+                raise LayerError(f"unknown archetype {tok!r}; known: {', '.join(known) or 'none'}{_suggest(tok, known)}")
+        else:
+            deferred.append(tok)
+    for tok in deferred:
+        candidates = _bare_candidates(manifest, tok)
+        if not candidates:
+            bare = sorted({k.split('/', 1)[1] for k in list(presets) + list(layer_table) if '/' in k})
+            raise LayerError(f"unknown name {tok!r}; known: {', '.join(bare) or 'none'}{_suggest(tok, bare + sorted(set(presets) | set(layer_table)))}")
+        if len(candidates) > 1:
+            narrowed = [c for c in candidates if c.split("/")[0] in langs]
+            # With no language named at all, a candidate marked `primary` in the
+            # manifest settles a bare name (js-ts is the primary shape of a Claude
+            # plugin; the Python one is supported, not the default -- djdarcy,
+            # 2026-10-22). A named language that does not narrow stays ambiguous.
+            primary = [c for c in candidates if (presets.get(c) or layer_table.get(c) or {}).get("primary")]
+            if len(narrowed) == 1:
+                candidates = narrowed
+            elif not langs and len(primary) == 1:
+                candidates = primary
+            else:
+                raise LayerError(f"{tok!r} is ambiguous: {' or '.join(candidates)}")
+        key = candidates[0]
+        if key in presets:
+            add_preset(key)
+        else:
+            add_layer(key)
+
+    # Rule 4: imply, transitively (a layer implies its language; its entry may imply more).
+    i = 0
+    while i < len(chosen):
+        folder, name = chosen[i]
+        if name:
+            lang_name = name.split("/")[0]
+            for imp in layer_table[name].get("implies", []):
+                target = imp if "/" in imp else f"{lang_name}/{imp}"
+                if target in table:              # a language
+                    add_language(target)
+                elif target in layer_table:
+                    pair = _layer(manifest, target)
+                    if pair not in chosen:
+                        chosen.append(pair)
+                else:
+                    raise LayerError(f"layer {name} implies {imp!r}, which the manifest does not define")
+        i += 1
+
+    # Rule 5: exclusivity, per language and facet.
+    seen: Dict[Tuple[str, str], str] = {}
+    for folder, name in chosen:
+        if not name:
+            continue
+        facet = layer_table[name].get("facet")
+        if facet and facet_exclusive(manifest, facet):
+            slot = (name.split("/")[0], facet)
+            other = seen.get(slot)
+            if other and other != name:
+                a, b = other.split("/", 1)[1], name.split("/", 1)[1]
+                raise LayerError(f"'{a}' and '{b}' are both a {facet} for {slot[0]}; pick one")
+            seen[slot] = name
+
+    # Rule 7 (default) when nothing was asked.
+    if not tokens:
+        for name in langs[:1]:   # the primary language's default only
+            default = table[name].get("default")
+            if default:
+                entry = presets.get(default)
+                if entry is None or entry.get("stub"):
+                    raise LayerError(f"language {name} names default archetype {default!r}, which is {'unknown' if entry is None else 'a stub'}")
+                add_preset(default)
+                res.archetype = default
+
+    # Rule 6: order -- the languages' own layers first (in the order given), then by facet rank, then as given.
+    order: List[Tuple[str, Optional[str]]] = []
+    for name in langs:
+        for folder in table[name].get("layers", []):
+            order.append((folder, name))
+    ranked = sorted(enumerate(chosen), key=lambda ic: (facet_rank(manifest, layer_table.get(ic[1][1] or "", {}).get("facet")), ic[0]))
+    order += [pair for _, pair in ranked]
+    for folder, name in order:
+        if folder not in res.layers:
+            res.layers.append(folder)
+            res.names.append(name or folder)
+    res.languages = langs
+
+    # Rule 8: recognise a preset -- the WHOLE request must equal the preset's
+    # expansion, languages included (`--language python --with minimal` is a
+    # two-language composition no preset vouches for, even though `minimal`
+    # alone is one).
+    if tokens and _recognise:
+        for key in presets_used + [k for k in presets if k not in presets_used]:
+            if presets[key].get("stub"):
+                continue
+            try:
+                expansion = resolve(manifest, [], [key], _recognise=False).layers
+            except LayerError:
+                continue
+            if expansion == res.layers:
+                res.archetype = key
+                break
+        if res.archetype is None:
+            res.notes.append(NOT_A_PRESET)
+
+    # A language with a default preset that ended up with no layer of its own
+    # (the second of two languages and no --with, or a --with naming only the
+    # other language's layers) is said out loud rather than left bare
+    # (Q261022-02, answered 2026-10-22: the person refines; no second default).
+    for name in langs:
+        default = table[name].get("default")
+        if default and not any(f.startswith(f"{ARCHETYPES_DIR}/{name}/") for f in res.layers):
+            res.notes.append(f"{name} got no preset of its own; add --with {name}/<name> (see `repokit list {name}`)")
+    return res
+
+
+def catalogue_lines(manifest: Dict[str, Any], language: Optional[str] = None) -> List[str]:
+    """`repokit list [LANG]`: per language, the presets (name = layers; planned
+    ones marked), then each facet with its choices and one-of / any-of."""
+    table = manifest["languages"]
+    if language and language not in table:
+        raise LayerError(f"unknown language {language!r}; known: {', '.join(known_languages(manifest))}")
+    facets = sorted(manifest["facets"].items(), key=lambda kv: kv[1].get("rank", UNRANKED))
+    lines: List[str] = []
+    for lang in sorted(table):
+        if language and lang != language:
+            continue
+        entry = table[lang]
+        if entry.get("pseudo"):
+            continue
+        head = f"{lang}:" + (f"  (planned: {entry.get('description', '')})" if entry.get("stub") else "")
+        lines.append(head)
+        default = entry.get("default")
+        for key in sorted(k for k in manifest["archetypes"] if k.startswith(lang + "/")):
+            preset = manifest["archetypes"][key]
+            if preset.get("stub"):
+                lines.append(f"  {key:28} (planned: {preset.get('description', '')})")
+            else:
+                parts = [f.split("/", 2)[-1] for f in preset.get("layers", [])]
+                mark = "  <- default" if key == default else ""
+                lines.append(f"  {key:28} = {', '.join(parts)}{mark}")
+        for facet, spec in facets:
+            if facet == "language":
+                continue
+            names = []
+            for key, l_entry in manifest["layers"].items():
+                if key.startswith(lang + "/") and l_entry.get("facet") == facet:
+                    names.append(key.split("/", 1)[1] + (" (planned)" if l_entry.get("stub") else ""))
+            if names:
+                pick = "one of" if spec.get("exclusive") else "any of"
+                lines.append(f"  {facet:10} {pick}: {', '.join(sorted(names))}")
+    return lines
+
+
+def _bare_candidates(manifest: Dict[str, Any], tok: str) -> List[str]:
+    """Qualified keys whose bare name is tok: one per language, a preset
+    preferred over a layer of the same name (the preset is the tested one)."""
+    by_lang: Dict[str, str] = {}
+    for key in manifest["layers"]:
+        lang, name = key.split("/", 1)
+        if name == tok and not is_pseudo(manifest, lang):
+            by_lang.setdefault(lang, key)
+    for key in manifest["archetypes"]:
+        lang, name = key.split("/", 1)
+        if name == tok:
+            by_lang[lang] = key
+    return [by_lang[l] for l in sorted(by_lang)]
+
+
+def _is_text(data: bytes) -> bool:
+    return b"\0" not in data[:8192]
+
+
+def layer_language(folder: str) -> Optional[str]:
+    """The language a layer folder belongs to: languages/<lang> or archetypes/<lang>/<name>."""
+    parts = folder.split("/")
+    return parts[1] if len(parts) >= 2 and parts[0] in ("languages", ARCHETYPES_DIR) else None
+
+
+def assemble(root: Path, layers: List[str], dest: str, context: Dict[str, Any],
+             engine: Optional[TemplateEngine] = None, preserve_existing: bool = False,
+             logger=None, primary_language: Optional[str] = None,
+             skipped: Optional[List[str]] = None) -> List[str]:
+    """Lay the layers down under ``dest``. Returns the files written or appended,
+    as dest-relative POSIX paths. ``context`` is token_context(...).
+
+    With ``primary_language`` set (a project of two or more languages), the
+    files in PRIMARY_ONLY come from that language's layers and the shared
+    `any` ones only: VS Code reads one launch.json, and merging two languages'
+    debug configurations is out of scope (0.9.2). Each file left out is
+    reported in ``skipped`` as "<language>: <path>"."""
+    engine = engine or TemplateEngine()
+    files: Dict[str, bytes] = {}        # template-relative path (tokens unresolved) -> content
+    appends: Dict[str, bytes] = {}      # appends whose target no layer provides: a file already on disk
+
+    for layer in layers:
+        base = root / layer
+        if not base.is_dir():
+            raise LayerError(f"layer folder missing: {layer} (under {root})")
+        lang = layer_language(layer)
+        for src in sorted(p for p in base.rglob("*") if p.is_file()):
+            # Bytecode beside the template sources (a syntax check compiled
+            # them) is not part of any layer, and carries the tokens inside.
+            if "__pycache__" in src.parts or src.suffix in (".pyc", ".pyo"):
+                continue
+            rel = src.relative_to(base).as_posix()
+            if primary_language and rel in PRIMARY_ONLY and lang not in (primary_language, "any", None):
+                if skipped is not None and f"{lang}: {rel}" not in skipped:
+                    skipped.append(f"{lang}: {rel}")
+                continue
+            data = src.read_bytes()
+            if rel.endswith(APPEND):
+                target = rel[: -len(APPEND)]
+                if target in files:
+                    files[target] = _joined(files[target], data)
+                else:
+                    appends[target] = _joined(appends.get(target, b""), data) if target in appends else data
+            else:
+                files[rel] = data   # a later layer's file replaces an earlier one
+
+    def out_path(rel: str) -> str:
+        resolved = engine.render_bytes(rel.encode("utf-8"), context, dollar=False).decode("utf-8")
+        if ".." in Path(resolved).parts:
+            raise LayerError(f"a layer path escapes the project: {rel}")
+        return resolved
+
+    written: List[str] = []
+    for rel, data in files.items():
+        is_workflow = rel.startswith(WORKFLOWS)
+        if is_workflow and RK_TOKEN.search(data.decode("latin-1")):
+            raise LayerError(f"token in workflow file {rel}: workflow files must stay placeholder-free")
+        target = out_path(rel)
+        full = os.path.join(dest, target)
+        if preserve_existing and os.path.exists(full):
+            if logger:
+                logger.info(f"Preserving existing file: {target}")
+            continue
+        if not is_workflow and _is_text(data):
+            data = engine.render_bytes(data, context, dollar=False)
+        os.makedirs(os.path.dirname(full) or dest, exist_ok=True)
+        with open(full, "wb") as f:
+            f.write(data)
+        written.append(target)
+
+    for rel, data in appends.items():
+        target = out_path(rel)
+        full = os.path.join(dest, target)
+        if preserve_existing and os.path.exists(full):
+            if logger:
+                logger.info(f"Preserving existing file, not appending: {target}")
+            continue
+        data = engine.render_bytes(data, context, dollar=False) if _is_text(data) else data
+        os.makedirs(os.path.dirname(full) or dest, exist_ok=True)
+        existing = open(full, "rb").read() if os.path.exists(full) else b""
+        with open(full, "wb") as f:
+            f.write(_joined(existing, data))
+        written.append(target)
+    return written
+
+
+def _joined(head: bytes, tail: bytes) -> bytes:
+    """head + tail, with a newline between when head has none at its end."""
+    if head and not head.endswith((b"\n", b"\r\n")):
+        head += b"\n"
+    return head + tail

repokit/licenses/0bsd.txt

@@ -0,0 +1,14 @@
+BSD Zero Clause License
+
+Copyright (c) __RK_YEAR__ __RK_HOLDER__
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

repokit/licenses/LICENSES.md

@@ -0,0 +1,27 @@
+# The licence catalogue: where each text came from, and its fingerprint
+
+Source: `github/choosealicense.com`, `_licenses/<id>.txt`, commit `f66c5dd01866041688edd87f658b6d5ac3304f1b` (branch gh-pages, fetched 2026-10-23 by `tests/one-offs/thinking/p4-fetch-licenses/fetch.py`). Each file's YAML front matter was stripped and the placeholders `[year]`, `[yyyy]`, `[fullname]`, `[name of copyright owner]` became `__RK_YEAR__` and `__RK_HOLDER__`; nothing else changed. `all-rights-reserved.txt` is authored here, not fetched. The "or-later" variants (`gpl-3.0-or-later`, `lgpl-3.0-or-later`, `agpl-3.0-or-later`) are not files: `repokit.licenses` renders them from the base text with a notice line, because the licence text is identical and only the project's notice says "or later".
+
+`tests/test_licenses.py` checks every shipped file against its shipped sha256; a changed file without a new row here fails.
+
+| id | SPDX | title | sha256 as received | sha256 as shipped | tokens |
+|---|---|---|---|---|---|
+| 0bsd | 0BSD | BSD Zero Clause License | 749c160d5a8290da254f5fd02a510c6a234df5aea2f4f0711f309f2d9a821899 | e41dbf5f8aa40ed502ea4ab4023de21795d556d9a341734f2d24872dc4973d0c | holder, year |
+| agpl-3.0 | AGPL-3.0 | GNU Affero General Public License v3.0 | 2a1fda78234b71502e2cf8035021b5592f5eba7e8107228aca4d95bba645e397 | 8486a10c4393cee1c25392769ddd3b2d6c242d6ec7928e1414efff7dfb2f07ef | none |
+| apache-2.0 | Apache-2.0 | Apache License 2.0 | 609e2cb599f84aaa41d8ef29d8fdb04d164fab22e8d9292ca34a599d0f56a338 | 7ab3d1eca77d69cf60cb1e56379fa9a619b6fc300155904e1f8539ee6155e9c4 | holder, year |
+| bsd-2-clause | BSD-2-Clause | BSD 2-Clause "Simplified" License | d8237d165c176416a8ab938bf7e120d8f345098163fcec9017c5652f467fecaf | fc29f42f5b8468afa3811a721ec1dd5c629f725e04785597ff4b7219887fe98e | holder, year |
+| bsd-3-clause | BSD-3-Clause | BSD 3-Clause "New" or "Revised" License | 732e653d6b57d83ee9bd21ff53c6dd1eb332628cefd05df4b99d523727dff664 | f5d1fc68fbc06c286a11125154784b0b21fab066a1574a29f928f7c564ec8461 | holder, year |
+| bsl-1.0 | BSL-1.0 | Boost Software License 1.0 | f8f6e066934a2365c12debd413b413caa0152791c87c0b16a12c8a65c3b92f9a | c9bff75738922193e67fa726fa225535870d2aa1059f91452c411736284ad566 | none |
+| cc-by-4.0 | CC-BY-4.0 | Creative Commons Attribution 4.0 International | 736763bf08829e36266b8a3bebcc041ac68575424e976490671a7e6b43a525cf | f5b745ef98087f531e719ee8ca6a96809444573ecc7173c6fa68eaad39b3cc3f | none |
+| cc-by-sa-4.0 | CC-BY-SA-4.0 | Creative Commons Attribution Share Alike 4.0 International | 8f85091fc554652d297119db8a092d8fc3d942ef3d768bd674decf48067a151f | 2003829cf643d61b00a76088dd31bb11b8029546f24c56b39fd492adb9281483 | none |
+| cc0-1.0 | CC0-1.0 | Creative Commons Zero v1.0 Universal | db8278dfdfc1f73224f9f3762922c378344ca0443d36800baa61b3aaf31ef0e2 | a2010f343487d3f7618affe54f789f5487602331c0a8d03f49e9a7c547cf0499 | none |
+| epl-2.0 | EPL-2.0 | Eclipse Public License 2.0 | 93c73b1678467af856e43dc4e7cc346991ab187b8da09b0e1a0cb010f6401ccd | 8c349f80764d0648e645f41ef23772a70c995a0924b5235f735f4a3d09df127c | none |
+| gpl-2.0 | GPL-2.0 | GNU General Public License v2.0 | b7c21f2a2d0a1558458adbd90b9380d2514cebf970d12f26f84f862571c30ee2 | 8177f97513213526df2cf6184d8ff986c675afb514d4e68a404010521b880643 | none |
+| gpl-3.0 | GPL-3.0 | GNU General Public License v3.0 | e9c13804a52b8aea2e30033764d1b19f98369bae58028d9d1eb6b84e42b888bc | 3972dc9744f6499f0f9b2dbf76696f2ae7ad8af9b23dde66d6af86c9dfb36986 | none |
+| isc | ISC | ISC License | 8ea92c9e801b11e1303173c3ce3fc566bbe1ede96190aaffbc5a0c97712146c8 | 491a83f2c57434db8e97565ec680a129960783ef2c5c10d3c1b9734bf0b4ee79 | holder, year |
+| lgpl-2.1 | LGPL-2.1 | GNU Lesser General Public License v2.1 | 0094ff7d2b4451d2231cd0c20b2798574c29bc81ef740d719a9909aabd86d633 | 20c17d8b8c48a600800dfd14f95d5cb9ff47066a9641ddeab48dc54aec96e331 | none |
+| lgpl-3.0 | LGPL-3.0 | GNU Lesser General Public License v3.0 | 0b2e8a7c7a977908fa0bfaa2e2a7a54e3fd73676662e9fedae264db2916e0135 | e3a994d82e644b03a792a930f574002658412f62407f5fee083f2555c5f23118 | none |
+| mit | MIT | MIT License | e6919db13cacb3300f918d1048d996d0f4506e1f110b7caa21f31ea7ca3ef5b8 | e3a0a9c39448343918a8bcbbf2dc5a0bce37cd0a937045ef6eeb869653fc0ec7 | holder, year |
+| mpl-2.0 | MPL-2.0 | Mozilla Public License 2.0 | 0e03b8171b7b830a6a416b403eced17d39baed5b3a60563971f8b27aaa4f29e6 | 3f3d9e0024b1921b067d6f7f88deb4a60cbe7a78e76c64e3f1d7fc3b779b9d04 | none |
+| unlicense | Unlicense | The Unlicense | ddc2e070df0bb25ce951b0954d9c1b5d22b17f150d58eac66bda653d044bb5ed | 6b0382b16279f26ff69014300541967a356a666eb0b91b422f6862f6b7dad17e | none |
+| all-rights-reserved | LicenseRef-AllRightsReserved | All rights reserved (authored here) | - | 1025ba5f1f4d5a5583b50ea511aa986aa557b1a417ef92f52fe0696b4e5565c9 | holder, year |