labforge 0.1.0__tar.gz → 0.2.0__tar.gz

labforge-0.2.0/CHANGELOG.md

@@ -0,0 +1,80 @@
+# Changelog
+
+Notable changes to labforge. Versions follow [semantic versioning](https://semver.org).
+
+## 0.2.0 — 2026-07-22
+
+- **`choice` param** — `Param(kind="choice", options=[...])` renders a Dropdown
+  and commits the selected string like any other control. The default must be
+  one of the options and the options must be non-empty (checked at registration);
+  a choice cannot be scanned.
+- **Theory-page selector** — `set_theory_selector(name, param, theory)` puts a
+  `choice` control on the Theory page whose value both rebuilds the theory
+  markdown (via a `theory(selection) -> markdown` callback) and writes the lab's
+  shared context. The static `set_theory` behavior is unchanged; the selector
+  takes precedence when both are set.
+- **Model-driven worker selector** — `set_theory_selector(..., selects_worker=True)`
+  makes the Theory dropdown the model switch: its options name registered workers,
+  and choosing one makes that worker active. The Simulation page then shows the
+  active worker as a single tab so it matches the tabbed Visualization and
+  Analysis pages.
+- **Shared context** — a per-session lab-level context that the Theory selector
+  writes and any worker, viz or analysis reads by declaring a `context`
+  parameter (injected at call time, never rendered as a control). So a choice is
+  made once and every page sees it.
+- **Multiple workers** — call `add_worker` more than once to build a lab with
+  several workers. Each worker keeps its own workspace (controls, last result,
+  and per-tab settings), and the `add_viz` / `add_analysis` calls after each
+  `add_worker` attach that worker's own tabs. Several workers need a way to choose
+  among them, checked at build: a `selects_worker` model selector, or
+  `worker_view="tabs"` to lay the workers out as Simulation-page tabs (sharing one
+  set of visualizations and analyses). There is no top-bar worker dropdown.
+  Single-worker labs are unchanged. (`worker_view` is `"panels"` by default, or
+  `"tabs"`.)
+- **Bundled fonts** — the app now ships its typefaces (Inter and Roboto Mono),
+  so the browser view renders the same faces and weights as the desktop window
+  instead of falling back to the platform default.
+- **Clearer theory errors** — `set_theory` now raises on a mistyped file path
+  (a missing `Path`, or a bare `".md"` string) instead of silently rendering the
+  path as a one-line page.
+- **Non-blocking Run** — the worker now runs off the UI thread, so a slow worker
+  no longer freezes the window. Run shows a `RUNNING…` status and disables the
+  button until the run settles. Fast workers are unaffected.
+
+## 0.1.1 — 2026-07-22
+
+Packaging and documentation only; no functional change.
+
+- Complete PyPI metadata: `readme`, keywords, trove classifiers, and project
+  URLs, so the project page renders the README and links back to the repository.
+- README image links use absolute URLs, so screenshots and the theme gallery
+  render on the PyPI project page rather than showing as broken images.
+
+## 0.1.0 — 2026-07-22
+
+Initial release.
+
+- **`Lab`** — register plain Python functions (one worker, any number of
+  visualization and analysis functions) and a markdown theory source, then
+  `open()` the assembled app: as a native desktop window or served to the
+  browser, laid out as four rail-navigated pages or one continuous scrolling
+  page. All registration is validated on the spot, so a malformed app fails at
+  assembly rather than mid-navigation.
+- **`Param` specs** — each worker/viz/analysis kwarg gets a UI control from its
+  `Param` (or a shorthand string such as `"int"` or `"scalar or array"`);
+  bounded params render as sliders with live readouts, unbounded ones as
+  validated text fields, tuples as per-element fields. Defaults are inferred
+  from the function signature.
+- **Parameter scans** — a kwarg declared `scan=True` accepts comma-separated
+  values; the worker runs once per point of the cartesian grid and downstream
+  functions receive a `ScanResult` of `(params, result)` records.
+- **Analysis dispatch** — an analysis may return a dict (two-column table), a
+  list of dicts or a DataFrame (table), a string (markdown), or a matplotlib
+  figure; the return shape picks the rendering.
+- **Themes** — eight palettes selected by `open(theme=...)`, four dark and
+  four light; chrome, plot palette and equation ink move together, and
+  `labforge.palette()` / `labforge.style(fig, ax)` let an author's figures
+  follow the active theme.
+- **LaTeX theory** — `$$...$$` blocks in the theory markdown render as crisp
+  equation images via system LaTeX, falling back to matplotlib mathtext.
+- **MIT licensed.**

{labforge-0.1.0 → labforge-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: labforge
-Version: 0.1.0
+Version: 0.2.0
 Summary: Wrap plain Python functions into a small scientific Flet desktop app: theory, simulation, visualization, analysis.
 Project-URL: Homepage, https://github.com/laroccod/labforge
 Project-URL: Repository, https://github.com/laroccod/labforge
@@ -35,15 +35,15 @@ Description-Content-Type: text/markdown
 
 *By Daniel La Rocco*
 
-## **Turn plain Python scripts into a small scientific desktop app.**
+## **Turn plain Python scripts into small scientific desktop apps.**
 
-labforge wraps a simulation you already have — a function that produces data,
+`labforge` wraps a simulation you already have — a function that produces data,
 a function that plots it, a function that summarizes it — into a polished
 four-section app following the **theory → simulation → visualization →
 analysis** workflow. Pure Python, rendered with [Flet](https://flet.dev); no
 HTML, no JavaScript, no callbacks to wire up.
 
-You provide the science and labforge supplies the app shell, the parameter controls
+You provide the science and `labforge` supplies the app shell, the parameter controls
 generated from your function signatures, the parameter-scan engine,
 LaTeX rendering for your theory notes, and eight instrument-panel themes, four
 dark and four light.
@@ -139,7 +139,7 @@ bounds, or a scan spec on a non-worker function raise `ValueError` when the
 app is assembled, never mid-use.
 
 **Parameter scans.** A kwarg declared `scan=True` gets a scan toggle (bounded)
-or a comma-separated field (unbounded). Enter `0, 1, 2` and labforge calls the
+or a comma-separated field (unbounded). Enter `0, 1, 2` and `labforge` calls the
 worker once per point of the cartesian grid across all scanned parameters —
 the worker itself always receives scalars. Downstream functions then receive a
 `ScanResult`: a list of `(params, result)` records with `keys`, `values()` and
@@ -147,7 +147,7 @@ the worker itself always receives scalars. Downstream functions then receive a
 
 **Visualizations.** Functions `viz(data, **kwargs)` returning a matplotlib
 figure (bare or `(fig, ax)`). Each gets a tab with its own controls and a
-Render button. Figures are yours — labforge only serializes them; the house
+Render button. Figures are yours — `labforge` only serializes them; the house
 style (`labforge.style(fig, ax)`) is strictly opt-in.
 
 **Analyses.** Functions `analysis(data, **kwargs)` — the return shape picks
@@ -161,6 +161,35 @@ the rendering:
 | Figure or `(fig, ax)` | image |
 | anything else | its `repr` |
 
+**Multiple workers.** Call `add_worker` more than once for a lab with several
+workers. Each worker keeps its own workspace — its controls, its last result and
+its per-tab settings — and the `add_viz` / `add_analysis` calls after each
+`add_worker` attach that worker's own tabs, so switching workers and back
+restores exactly what was there. Several workers need a way to choose among them
+(checked at build): a `selects_worker` model selector, or `worker_view="tabs"`
+to lay the workers out as Simulation-page tabs.
+
+The clean way is a Theory-page selector with `selects_worker=True`: its options
+name the workers, so choosing one both swaps the theory and makes that worker
+active. There is no top-bar dropdown; the Simulation page shows the active
+worker as a single tab, matching the tabbed Visualization and Analysis pages.
+The demo (`examples/demo_lab.py`) uses this to switch between a normal and a
+gamma model:
+
+```python
+lab.set_theory_selector(
+    "model",
+    Param(kind="choice", options=["Normal", "Gamma"]),
+    theory_for,                 # theory_for(selection) -> markdown
+    label="Distribution",
+    selects_worker=True,
+)
+lab.add_worker(sample, {...}, name="Normal")   # its own viz/analysis tabs
+lab.add_worker(sample_gamma, {...}, name="Gamma")
+```
+
+![The Theory model selector driving the active worker: choosing Gamma shows the gamma theory and the gamma worker as a single Simulation tab](https://raw.githubusercontent.com/laroccod/labforge/main/assets/multi_worker.png)
+
 **Theory.** A markdown file or string. Displayed `$$...$$` equations render as
 crisp images — through your system LaTeX toolchain when one is installed
 (with the Euler math font), falling back to matplotlib's mathtext otherwise.
@@ -203,7 +232,13 @@ the theme's ink:
 
 ## Install
 
-Requires Python ≥ 3.10. Not yet on PyPI — install from a clone:
+Requires Python ≥ 3.10.
+
+```bash
+pip install labforge
+```
+
+Or from a clone, if you want to work on the code directly:
 
 ```bash
 git clone https://github.com/laroccod/labforge.git

{labforge-0.1.0 → labforge-0.2.0}/README.md

@@ -2,15 +2,15 @@
 
 *By Daniel La Rocco*
 
-## **Turn plain Python scripts into a small scientific desktop app.**
+## **Turn plain Python scripts into small scientific desktop apps.**
 
-labforge wraps a simulation you already have — a function that produces data,
+`labforge` wraps a simulation you already have — a function that produces data,
 a function that plots it, a function that summarizes it — into a polished
 four-section app following the **theory → simulation → visualization →
 analysis** workflow. Pure Python, rendered with [Flet](https://flet.dev); no
 HTML, no JavaScript, no callbacks to wire up.
 
-You provide the science and labforge supplies the app shell, the parameter controls
+You provide the science and `labforge` supplies the app shell, the parameter controls
 generated from your function signatures, the parameter-scan engine,
 LaTeX rendering for your theory notes, and eight instrument-panel themes, four
 dark and four light.
@@ -106,7 +106,7 @@ bounds, or a scan spec on a non-worker function raise `ValueError` when the
 app is assembled, never mid-use.
 
 **Parameter scans.** A kwarg declared `scan=True` gets a scan toggle (bounded)
-or a comma-separated field (unbounded). Enter `0, 1, 2` and labforge calls the
+or a comma-separated field (unbounded). Enter `0, 1, 2` and `labforge` calls the
 worker once per point of the cartesian grid across all scanned parameters —
 the worker itself always receives scalars. Downstream functions then receive a
 `ScanResult`: a list of `(params, result)` records with `keys`, `values()` and
@@ -114,7 +114,7 @@ the worker itself always receives scalars. Downstream functions then receive a
 
 **Visualizations.** Functions `viz(data, **kwargs)` returning a matplotlib
 figure (bare or `(fig, ax)`). Each gets a tab with its own controls and a
-Render button. Figures are yours — labforge only serializes them; the house
+Render button. Figures are yours — `labforge` only serializes them; the house
 style (`labforge.style(fig, ax)`) is strictly opt-in.
 
 **Analyses.** Functions `analysis(data, **kwargs)` — the return shape picks
@@ -128,6 +128,35 @@ the rendering:
 | Figure or `(fig, ax)` | image |
 | anything else | its `repr` |
 
+**Multiple workers.** Call `add_worker` more than once for a lab with several
+workers. Each worker keeps its own workspace — its controls, its last result and
+its per-tab settings — and the `add_viz` / `add_analysis` calls after each
+`add_worker` attach that worker's own tabs, so switching workers and back
+restores exactly what was there. Several workers need a way to choose among them
+(checked at build): a `selects_worker` model selector, or `worker_view="tabs"`
+to lay the workers out as Simulation-page tabs.
+
+The clean way is a Theory-page selector with `selects_worker=True`: its options
+name the workers, so choosing one both swaps the theory and makes that worker
+active. There is no top-bar dropdown; the Simulation page shows the active
+worker as a single tab, matching the tabbed Visualization and Analysis pages.
+The demo (`examples/demo_lab.py`) uses this to switch between a normal and a
+gamma model:
+
+```python
+lab.set_theory_selector(
+    "model",
+    Param(kind="choice", options=["Normal", "Gamma"]),
+    theory_for,                 # theory_for(selection) -> markdown
+    label="Distribution",
+    selects_worker=True,
+)
+lab.add_worker(sample, {...}, name="Normal")   # its own viz/analysis tabs
+lab.add_worker(sample_gamma, {...}, name="Gamma")
+```
+
+![The Theory model selector driving the active worker: choosing Gamma shows the gamma theory and the gamma worker as a single Simulation tab](https://raw.githubusercontent.com/laroccod/labforge/main/assets/multi_worker.png)
+
 **Theory.** A markdown file or string. Displayed `$$...$$` equations render as
 crisp images — through your system LaTeX toolchain when one is installed
 (with the Euler math font), falling back to matplotlib's mathtext otherwise.
@@ -170,7 +199,13 @@ the theme's ink:
 
 ## Install
 
-Requires Python ≥ 3.10. Not yet on PyPI — install from a clone:
+Requires Python ≥ 3.10.
+
+```bash
+pip install labforge
+```
+
+Or from a clone, if you want to work on the code directly:
 
 ```bash
 git clone https://github.com/laroccod/labforge.git

{labforge-0.1.0 → labforge-0.2.0}/examples/demo_lab.py

@@ -1,16 +1,22 @@
 """
 Demo lab
 
-The labforge README example in runnable form: a Gaussian sampler worker, a
-histogram (with fitted density) and Q-Q plot visualization, and a moments
-analysis, each handling both a single run and a parameter scan. Launch with
-`python examples/demo_lab.py`; add `--browser [port]` to serve it to the
-default web browser instead, `--scroll` for one continuous scrolling page
+Two samplers on one lab, to show off multiple workers and the Theory-page model
+selector. A normal worker carries a histogram (with fitted density), a Q-Q plot
+and a moments table; a gamma worker carries its own histogram and a
+method-of-moments fit. The Theory-page dropdown is the single model switch
+(selects_worker=True): choosing Normal or Gamma swaps the theory math and makes
+that worker active, so the Simulation page shows its parameters as one tab and
+the Visualization and Analysis pages show its own tabs. No top-bar worker
+dropdown is needed. Each worker handles both a single run and a parameter scan.
+Launch with `python examples/demo_lab.py`; add `--browser [port]` to serve it to
+the default web browser instead, `--scroll` for one continuous scrolling page
 instead of four, and/or `--theme <name>` to try a colour scheme (see
 labforge.themes()).
 """
 
 import argparse
+from math import gamma as gamma_func
 from pathlib import Path
 from statistics import NormalDist
 
@@ -20,12 +26,32 @@ import numpy as np
 import labforge
 from labforge import Lab, Param, ScanResult
 
-lab = Lab("gausslab")
-lab.set_theory(Path(__file__).with_name("theory.md"))
+lab = Lab("statlab")
+
+# The Theory page carries a dropdown that swaps the whole page between the two
+# families; each option maps to its own markdown source.
+THEORY = {
+    "Normal": Path(__file__).with_name("theory.md").read_text(encoding="utf-8"),
+    "Gamma": Path(__file__).with_name("theory_gamma.md").read_text(encoding="utf-8"),
+}
+
+
+def theory_for(model):
+    """The theory markdown for the selected distribution."""
+    return THEORY[model]
+
+
+lab.set_theory_selector(
+    "model",
+    Param(kind="choice", options=["Normal", "Gamma"], default="Normal"),
+    theory_for,
+    label="Distribution",
+    selects_worker=True,
+)
 
 
 def sample(mu=0.0, sigma=1.0, n=2000, seed=42):
-    """Draw n Gaussian variates; reproducible for a given seed."""
+    """Draw n normal variates; reproducible for a given seed."""
     return np.random.default_rng(seed).normal(mu, sigma, n)
 
 
@@ -37,6 +63,7 @@ lab.add_worker(
         "n": Param(kind="int", default=2000, bounds=(10, 100_000)),
         "seed": "int",
     },
+    name="Normal",
 )
 
 
@@ -131,6 +158,92 @@ lab.add_analysis(
 )
 
 
+# The gamma worker. Registering a second worker turns the top bar into a model
+# selector, and add_viz/add_analysis below attach to this worker, not the normal
+# one, so each model owns its own tabs.
+def sample_gamma(shape=2.0, scale=1.0, n=2000, seed=42):
+    """Draw n gamma variates; reproducible for a given seed."""
+    return np.random.default_rng(seed).gamma(shape, scale, n)
+
+
+lab.add_worker(
+    sample_gamma,
+    {
+        "shape": Param(default=2.0, bounds=(0.5, 10), scan=True),
+        "scale": Param(default=1.0, bounds=(0.1, 4), scan=True),
+        "n": Param(kind="int", default=2000, bounds=(10, 100_000)),
+        "seed": "int",
+    },
+    name="Gamma",
+)
+
+
+def gamma_density(x, shape, scale):
+    """The gamma density at x for shape k and scale θ."""
+    return x ** (shape - 1) * np.exp(-x / scale) / (scale**shape * gamma_func(shape))
+
+
+def gamma_histogram(data, bins=40):
+    """Density histogram of the draw; a scan overlays one histogram per point."""
+    fig, ax = plt.subplots(figsize=(7, 3.4))
+    if isinstance(data, ScanResult):
+        for params, draws in data:
+            label = ", ".join(f"{key} = {params[key]:g}" for key in data.keys)
+            ax.hist(draws, bins=bins, density=True, alpha=0.5, label=label)
+    else:
+        colors = labforge.palette()
+        ax.hist(data, bins=bins, density=True, color=colors.data, label="draw")
+        # The method-of-moments fit: shape and scale from the sample mean and variance.
+        mean, var = np.mean(data), np.var(data, ddof=1)
+        shape, scale = mean**2 / var, var / mean
+        x = np.linspace(np.min(data), np.max(data), 400)
+        ax.plot(
+            x,
+            gamma_density(x, shape, scale),
+            color=colors.model,
+            linewidth=1.6,
+            label="fitted density",
+        )
+    ax.legend()
+    ax.set_xlabel("x")
+    ax.set_ylabel("density")
+    labforge.style(fig, ax)
+    return fig, ax
+
+
+lab.add_viz(
+    gamma_histogram,
+    "Histogram",
+    "Density-normalized histogram of the most recent draw, with the "
+    "method-of-moments gamma density on top. On a scan, one translucent "
+    "histogram per grid point shows how the shape sharpens and the scale "
+    "stretches the density.",
+    {"bins": Param(kind="int", default=40, bounds=(5, 200))},
+)
+
+
+def gamma_fit(data):
+    """Method-of-moments shape and scale from the sample moments; one row per grid point on a scan."""
+
+    def row(draws):
+        mean, var = float(np.mean(draws)), float(np.var(draws, ddof=1))
+        return {"shape": mean**2 / var, "scale": var / mean, "mean": mean}
+
+    if isinstance(data, ScanResult):
+        return [{**params, **row(draws)} for params, draws in data]
+    return row(data)
+
+
+lab.add_analysis(
+    gamma_fit,
+    "Fit",
+    "The mean is kθ and the variance is kθ², so the method of moments recovers "
+    "the shape as X̄²/s² and the scale as s²/X̄. The maximum-likelihood shape "
+    "has no closed form for this family, so the sample moments are the quick "
+    "estimate.",
+)
+
+
 if __name__ == "__main__":
     parser = argparse.ArgumentParser(description="Run the labforge Gaussian demo.")
     parser.add_argument(

labforge-0.2.0/examples/theory_gamma.md

@@ -0,0 +1,37 @@
+## The gamma distribution
+
+A gamma variable is the total of k independent exponential waiting times, each
+with mean θ, so it models the time until the k-th event of a memoryless process.
+Its support is the positive reals and its shape is right-skewed. A variable X
+with shape k and scale θ has density
+
+$$f(x) = \frac{1}{\theta^{k}\,\Gamma(k)}\; x^{k-1}\, e^{-x/\theta} \,, \qquad x > 0$$
+
+The shape k sets how many waiting times are summed and the scale θ stretches the
+axis. As k grows the sum of many exponentials becomes more symmetric and
+approaches a normal density, the central limit theorem acting from inside the
+family.
+
+## Estimation
+
+The first two moments give the parameters directly through
+
+$$\mathrm{E}[X] = k\theta \,, \qquad \mathrm{Var}[X] = k\theta^{2}$$
+
+so the method of moments inverts them into
+
+$$\hat{k} = \frac{\bar{X}^{2}}{s^{2}} \,, \qquad
+\hat{\theta} = \frac{s^{2}}{\bar{X}}$$
+
+where X̄ is the sample mean and s² the sample variance. Unlike the normal family
+the maximum-likelihood shape has no closed form and is found numerically, so the
+method of moments is the quick estimate the analysis tab reports.
+
+## What the simulation shows
+
+The worker draws n independent gamma variates with numpy's `default_rng(seed)`,
+so a given seed reproduces the sample. The **histogram** compares the draw
+against its method-of-moments density, and the **fit** analysis recovers the
+shape and scale from the sample moments. Scanning the shape sharpens the density
+and pulls it toward symmetry as k rises, and scanning the scale stretches it
+along the x axis without changing its form.

{labforge-0.1.0 → labforge-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "labforge"
-version = "0.1.0"
+version = "0.2.0"
 description = "Wrap plain Python functions into a small scientific Flet desktop app: theory, simulation, visualization, analysis."
 readme = "README.md"
 license = "MIT"

labforge-0.2.0/src/labforge/assets/fonts/Inter-OFL.txt

@@ -0,0 +1,93 @@
+Copyright 2020 The Inter Project Authors (https://github.com/rsms/inter)
+
+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://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+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.