sciencelogo-documenter 0.0.1__py3-none-any.whl

sciencelogo_documenter/__init__.py

@@ -0,0 +1,3 @@
+"""Readable websites and PDF booklets from ScienceLogo workflows."""
+
+__version__ = "0.0.1"

sciencelogo_documenter/__main__.py

@@ -0,0 +1,3 @@
+from sciencelogo_documenter.cli import main
+
+raise SystemExit(main())

sciencelogo_documenter/booklet.py

@@ -0,0 +1,18 @@
+"""Compiles the booklet with Typst."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typst
+
+
+def compile_booklet(source: Path, output: Path, font_dirs: list[Path]) -> None:
+    """Compile `source` (booklet.typ) to the PDF `output`, using only the given fonts."""
+    typst.compile(
+        str(source),
+        output=str(output),
+        root=str(source.parent),
+        font_paths=[str(d) for d in font_dirs],
+        ignore_system_fonts=True,
+    )

sciencelogo_documenter/bootstrap.py

@@ -0,0 +1,111 @@
+"""Racket and the `sciencelogo` package, downloaded once and kept in a cache."""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import platform
+import shutil
+import subprocess
+import sys
+import tarfile
+import tempfile
+import urllib.request
+from pathlib import Path
+
+from sciencelogo_documenter import versions
+
+
+class BootstrapError(RuntimeError):
+    pass
+
+
+def cache_root() -> Path:
+    """The folder that holds the Documenter's downloads."""
+    explicit = os.environ.get("SCIENCELOGO_DOCUMENTER_CACHE")
+    if explicit:
+        return Path(explicit)
+    base = os.environ.get("XDG_CACHE_HOME")
+    return (Path(base) if base else Path.home() / ".cache") / "sciencelogo-documenter"
+
+
+def platform_key() -> str:
+    machine = platform.machine().lower()
+    system = platform.system().lower()
+    if machine in ("x86_64", "amd64") and system == "linux":
+        return "x86_64-linux"
+    raise BootstrapError(f"no pinned Racket build for {system} on {machine}")
+
+
+def _versions(overrides: dict | None) -> dict:
+    overrides = overrides or {}
+    url, sha256 = (None, None)
+    if overrides.get("racket_url"):
+        url, sha256 = overrides["racket_url"], overrides.get("racket_sha256")
+    else:
+        url, sha256 = versions.racket_tarball(platform_key())
+    return {
+        "racket_url": url,
+        "racket_sha256": sha256,
+        "sciencelogo_url": overrides.get("sciencelogo_url") or versions.SCIENCELOGO_URL,
+        "sciencelogo_checksum": overrides.get("sciencelogo_checksum") or versions.SCIENCELOGO_CHECKSUM,
+    }
+
+
+def _download(url: str, dest: Path) -> None:
+    with urllib.request.urlopen(url, timeout=120) as response, open(dest, "wb") as out:
+        shutil.copyfileobj(response, out)
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with open(path, "rb") as f:
+        for chunk in iter(lambda: f.read(1 << 20), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def racket_bin(overrides: dict | None = None) -> Path:
+    """Return the `bin` folder of a Racket that has `sciencelogo` installed.
+
+    The environment variable SCIENCELOGO_DOCUMENTER_RACKET can name the `bin`
+    folder of an existing installation instead.
+    """
+    existing = os.environ.get("SCIENCELOGO_DOCUMENTER_RACKET")
+    if existing:
+        return Path(existing)
+
+    chosen = _versions(overrides)
+    key = hashlib.sha256(repr(sorted(chosen.items())).encode()).hexdigest()[:12]
+    dest = cache_root() / f"racket-{key}"
+    if (dest / ".complete").exists():
+        return dest / "bin"
+
+    print("Installing Racket and the sciencelogo package (first run only)...", file=sys.stderr)
+    cache_root().mkdir(parents=True, exist_ok=True)
+    if dest.exists():
+        shutil.rmtree(dest)
+    with tempfile.TemporaryDirectory(dir=cache_root()) as tmp:
+        tmp_path = Path(tmp)
+        tarball = tmp_path / "racket.tgz"
+        _download(chosen["racket_url"], tarball)
+        if chosen["racket_sha256"] and _sha256(tarball) != chosen["racket_sha256"]:
+            raise BootstrapError("the Racket download does not match its pinned checksum")
+        with tarfile.open(tarball) as archive:
+            archive.extractall(tmp_path / "unpacked", filter="data")
+        # Racket is installed in place, so it is moved before any package is added.
+        (tmp_path / "unpacked" / "racket").rename(dest)
+    result = subprocess.run(
+        [
+            str(dest / "bin" / "raco"), "pkg", "install", "--auto", "--batch", "--no-docs",
+            "--scope", "installation",
+            "--checksum", chosen["sciencelogo_checksum"],
+            chosen["sciencelogo_url"],
+        ],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        raise BootstrapError("installing the sciencelogo package failed:\n" + result.stderr[-4000:])
+    (dest / ".complete").write_text("ok\n")
+    return dest / "bin"

sciencelogo_documenter/build.py

@@ -0,0 +1,96 @@
+"""Builds the website and the booklet of one workflow."""
+
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+import sys
+import tempfile
+from importlib.resources import as_file, files
+from pathlib import Path
+
+from sciencelogo_documenter import bootstrap, config
+from sciencelogo_documenter.booklet import compile_booklet
+
+
+class BuildError(RuntimeError):
+    pass
+
+
+def git_root(path: Path) -> Path:
+    result = subprocess.run(
+        ["git", "-C", str(path), "rev-parse", "--show-toplevel"],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        raise BuildError(f"{path} is not in a Git repository; ScienceLogo includes require one")
+    return Path(result.stdout.strip())
+
+
+def build(entry: Path, out: Path, config_path: Path | None = None) -> Path:
+    """Build `out/site`, with the booklet inside it. Return the site folder.
+
+    If the workflow is invalid, nothing is written and BuildError carries the
+    reader's message.
+    """
+    entry = entry.resolve()
+    if not entry.is_file():
+        raise BuildError(f"{entry} does not exist")
+    root = git_root(entry.parent)
+    if config_path is None and (root / config.CONFIG_NAME).is_file():
+        config_path = root / config.CONFIG_NAME
+    settings, warnings = config.load(config_path)
+    for w in warnings:
+        print(f"warning: {w}", file=sys.stderr)
+
+    racket = bootstrap.racket_bin(settings["versions"]) / "racket"
+    package = files("sciencelogo_documenter")
+    with as_file(package) as package_dir, tempfile.TemporaryDirectory() as tmp:
+        package_dir = Path(package_dir)
+        tmp_path = Path(tmp)
+        site = tmp_path / "site"
+        work = tmp_path / "work"
+        work.mkdir()
+
+        # Files named in the settings are copied next to the outputs.
+        faces = []
+        for i, face in enumerate(settings["fonts"]["faces"]):
+            name = f"{i}-{Path(face['file']).name}"
+            faces.append({**face, "url": f"fonts/custom/{name}", "name": name})
+        settings["fonts"]["faces"] = faces
+        if settings["booklet"].get("logo"):
+            logo = Path(settings["booklet"]["logo"])
+            shutil.copyfile(logo, work / f"logo{logo.suffix}")
+            settings["booklet"]["logo_file"] = f"logo{logo.suffix}"
+        settings_file = tmp_path / "settings.json"
+        settings_file.write_text(json.dumps(settings))
+
+        result = subprocess.run(
+            [str(racket), str(package_dir / "racket" / "main.rkt"), "build",
+             str(entry), str(settings_file), str(site), str(work)],
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode != 0:
+            raise BuildError(result.stderr.strip() or "the build failed")
+        if result.stderr.strip():
+            print(result.stderr.strip(), file=sys.stderr)
+
+        font_dirs = [package_dir / "fonts" / "atkinson-hyperlegible-next",
+                     package_dir / "fonts" / "atkinson-hyperlegible-mono"]
+        if faces:
+            custom = site / "fonts" / "custom"
+            custom.mkdir(parents=True, exist_ok=True)
+            for face in faces:
+                shutil.copyfile(face["file"], custom / face["name"])
+            font_dirs.insert(0, custom)
+        compile_booklet(work / "booklet.typ", site / "booklet.pdf", font_dirs)
+
+        out.mkdir(parents=True, exist_ok=True)
+        target = out / "site"
+        if target.exists():
+            shutil.rmtree(target)
+        shutil.move(str(site), str(target))
+    return target

sciencelogo_documenter/cli.py

@@ -0,0 +1,65 @@
+"""Command line entry point."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from collections.abc import Sequence
+from pathlib import Path
+
+from sciencelogo_documenter import __version__
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="sciencelogo-documenter",
+        description="Readable websites and PDF booklets from ScienceLogo workflows.",
+    )
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    commands = parser.add_subparsers(dest="command", required=True)
+
+    build = commands.add_parser("build", help="build the website and the booklet")
+    build.add_argument("entry", type=Path, help="the workflow's entry file")
+    build.add_argument("--out", type=Path, default=Path("documentation"),
+                       help="output folder (default: documentation)")
+    build.add_argument("--config", type=Path, help="settings file (default: sciencelogo-documenter.toml "
+                       "at the root of the workflow repository, if present)")
+
+    publish = commands.add_parser("publish", help="publish a built website")
+    publish.add_argument("--target", required=True,
+                         choices=["pages-branch", "github-pages", "gitlab-pages", "dir"])
+    publish.add_argument("--site", type=Path, default=Path("documentation/site"),
+                         help="the built website (default: documentation/site)")
+    publish.add_argument("--branch", default="pages", help="branch for pages-branch (default: pages)")
+    publish.add_argument("--remote", default="origin", help="remote for pages-branch (default: origin)")
+    publish.add_argument("--folder", type=Path, help="destination folder for github-pages, gitlab-pages or dir")
+
+    commands.add_parser("bootstrap", help=argparse.SUPPRESS)
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    try:
+        if args.command == "build":
+            from sciencelogo_documenter.build import build
+
+            site = build(args.entry, args.out, args.config)
+            print(f"Built {site}")
+        elif args.command == "publish":
+            from sciencelogo_documenter.publish import publish
+
+            where = publish(args.target, args.site, branch=args.branch, folder=args.folder,
+                            remote=args.remote)
+            print(f"Published to {where}")
+        elif args.command == "bootstrap":
+            from sciencelogo_documenter.bootstrap import racket_bin
+
+            print(racket_bin())
+    except Exception as e:  # noqa: BLE001 - every failure ends with a readable message
+        name = type(e).__name__
+        if name in ("BuildError", "PublishError", "ConfigError", "BootstrapError"):
+            print(f"error: {e}", file=sys.stderr)
+            return 1
+        raise
+    return 0

sciencelogo_documenter/config.py

@@ -0,0 +1,143 @@
+"""Settings: the standard style, overridden by an optional TOML file."""
+
+from __future__ import annotations
+
+import copy
+import tomllib
+from pathlib import Path
+
+CONFIG_NAME = "sciencelogo-documenter.toml"
+
+# The standard style. Colours of the categories are Okabe-Ito hues, used as
+# markers next to a type style that carries the meaning on its own.
+DEFAULTS: dict = {
+    "title": None,
+    "site": {"logo": None},
+    "layout": {"page_depth": 3},
+    "booklet": {"paper": "a4", "body_size": "10.5pt", "logo": None},
+    "fonts": {
+        "text": "Atkinson Hyperlegible Next",
+        "code": "Atkinson Hyperlegible Mono",
+        "faces": [],
+    },
+    "colours": {
+        "light": {
+            "background": "#ffffff",
+            "text": "#1a1a1a",
+            "muted": "#555555",
+            "link": "#1d4f91",
+            "border": "#d0d0d0",
+            "code_background": "#f4f4f4",
+        },
+        "dark": {
+            "background": "#121212",
+            "text": "#ececec",
+            "muted": "#b0b0b0",
+            "link": "#8ab4f8",
+            "border": "#3a3a3a",
+            "code_background": "#1e1e1e",
+        },
+        "categories": {
+            "light": {"stage": "#0072B2", "performer": "#E69F00", "procedure": "#009E73", "uncertainty": "#D55E00"},
+            "dark": {"stage": "#56B4E9", "performer": "#E69F00", "procedure": "#009E73", "uncertainty": "#D55E00"},
+        },
+    },
+    "index": {"kinds": ["Stages", "Procedures", "Performers", "Record types", "Requirements"]},
+    "versions": {
+        "racket_url": None,
+        "racket_sha256": None,
+        "sciencelogo_url": None,
+        "sciencelogo_checksum": None,
+    },
+}
+
+
+class ConfigError(ValueError):
+    pass
+
+
+def _merge(base: dict, override: dict, where: str, warnings: list[str]) -> dict:
+    result = copy.deepcopy(base)
+    for key, value in override.items():
+        name = f"{where}.{key}" if where else key
+        if key not in base:
+            warnings.append(f"unknown setting {name!r} is ignored")
+            continue
+        if isinstance(base[key], dict) and isinstance(value, dict):
+            result[key] = _merge(base[key], value, name, warnings)
+        else:
+            result[key] = value
+    return result
+
+
+def _luminance(colour: str) -> float:
+    c = colour.lstrip("#")
+    if len(c) == 3:
+        c = "".join(ch * 2 for ch in c)
+    channels = [int(c[i:i + 2], 16) / 255 for i in (0, 2, 4)]
+    linear = [ch / 12.92 if ch <= 0.03928 else ((ch + 0.055) / 1.055) ** 2.4 for ch in channels]
+    return 0.2126 * linear[0] + 0.7152 * linear[1] + 0.0722 * linear[2]
+
+
+def contrast(a: str, b: str) -> float:
+    """WCAG contrast ratio of two colours written as #rrggbb."""
+    la, lb = sorted((_luminance(a), _luminance(b)), reverse=True)
+    return (la + 0.05) / (lb + 0.05)
+
+
+def contrast_warnings(settings: dict) -> list[str]:
+    warnings = []
+    for mode in ("light", "dark"):
+        palette = settings["colours"][mode]
+        for key in ("text", "muted", "link"):
+            try:
+                ratio = contrast(palette[key], palette["background"])
+            except (KeyError, ValueError):
+                warnings.append(f"colours.{mode}.{key} is not a #rrggbb colour")
+                continue
+            if ratio < 4.5:
+                warnings.append(
+                    f"colours.{mode}.{key} has a contrast of {ratio:.1f}:1 with the background, below 4.5:1"
+                )
+    return warnings
+
+
+def load(path: Path | None) -> tuple[dict, list[str]]:
+    """Return the settings and any warnings. Paths in the file are resolved
+    against the file's folder."""
+    warnings: list[str] = []
+    if path is None:
+        settings = copy.deepcopy(DEFAULTS)
+    else:
+        try:
+            with open(path, "rb") as f:
+                data = tomllib.load(f)
+        except OSError as e:
+            raise ConfigError(f"cannot read {path}: {e}") from None
+        except tomllib.TOMLDecodeError as e:
+            raise ConfigError(f"{path} is not valid TOML: {e}") from None
+        settings = _merge(DEFAULTS, data, "", warnings)
+        base = path.parent
+        for section in ("site", "booklet"):
+            logo = settings[section].get("logo")
+            if logo:
+                resolved = (base / logo).resolve()
+                if not resolved.is_file():
+                    raise ConfigError(f"{section}.logo: {logo} does not exist")
+                settings[section]["logo"] = str(resolved)
+        faces = []
+        for face in settings["fonts"].get("faces") or []:
+            if not isinstance(face, dict) or "family" not in face or "file" not in face:
+                raise ConfigError("each fonts.faces entry needs a family and a file")
+            resolved = (base / face["file"]).resolve()
+            if not resolved.is_file():
+                raise ConfigError(f"fonts.faces: {face['file']} does not exist")
+            faces.append({**face, "file": str(resolved)})
+        settings["fonts"]["faces"] = faces
+    try:
+        depth = int(settings["layout"]["page_depth"])
+    except (TypeError, ValueError):
+        raise ConfigError("layout.page_depth must be a number") from None
+    settings["layout"]["page_depth"] = depth
+    warnings.extend(contrast_warnings(settings))
+    return settings, warnings

sciencelogo_documenter/fonts/atkinson-hyperlegible-mono/OFL.txt

@@ -0,0 +1,93 @@
+Copyright 2020-2024 The Atkinson Hyperlegible Mono Project Authors (https://github.com/googlefonts/atkinson-hyperlegible-next-mono)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+https://openfontlicense.org
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

sciencelogo_documenter/fonts/atkinson-hyperlegible-next/OFL.txt

@@ -0,0 +1,93 @@
+Copyright 2020-2024 The Atkinson Hyperlegible Next Project Authors (https://github.com/googlefonts/atkinson-hyperlegible-next)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+https://openfontlicense.org
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.