kitchenbench 0.3.0__py3-none-any.whl

kitchenbench/tasks.py

@@ -0,0 +1,169 @@
+"""The 10 KitchenBench tasks, generated from :data:`kitchenbench.specs.SPECS`.
+
+Each task instance (a stochastic setup + goal) becomes one Inspect Robots ``Scene``;
+each task runs ``K_REALIZATIONS`` (5) realizations per instance via
+``Epochs(count=5, reducer="mean")``, so the per-scene reduced ``task_success`` is
+the methodology's instance success probability P̂[Yᵢ=1]. With ``K_INSTANCES`` (5)
+instances per task that is 5 scenes x 5 epochs per task.
+
+Each task is registered with Inspect Robots under ``kitchenbench/<key>`` (the slash
+namespaces KitchenBench within WorldEvals). The entry-point name, the ``@task``
+name, and the returned ``Task.name`` are all identical.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import asdict
+from typing import Any
+
+from inspect_robots import Epochs, Scene, Target, Task, episode_length, task
+from inspect_robots.rollout import derive_seed
+
+from kitchenbench.instances import K_INSTANCES, K_REALIZATIONS, Realization
+from kitchenbench.scoring import task_success
+from kitchenbench.specs import SPEC_BY_KEY, TaskSpec
+
+_SLUG_RE = re.compile(r"[^a-z0-9]+")
+
+
+def _slug(text: str) -> str:
+    return _SLUG_RE.sub("-", text.lower()).strip("-")
+
+
+def _validation_dict(spec_validation: Any) -> dict[str, Any]:
+    """``asdict`` a Validation, casting rating tuples to lists for clean JSON."""
+    return {k: (list(v) if isinstance(v, tuple) else v) for k, v in asdict(spec_validation).items()}
+
+
+def build_scenes(spec: TaskSpec) -> list[Scene]:
+    """Build one Scene per task instance (5 per task)."""
+    scenes: list[Scene] = []
+    for index, inst in enumerate(spec.instances):
+        # The displayed instruction is the realization of epoch 0 under the default
+        # eval(seed=0), so it equals the first actual rollout's instruction.
+        canonical = inst.realize(derive_seed(0, index, 0))
+        scenes.append(
+            Scene(
+                id=_slug(inst.instance_id),
+                instruction=canonical.instruction,
+                target=Target(kind=inst.target_kind, spec=dict(inst.static)),
+                init_seed=index,
+                metadata={
+                    "benchmark": "kitchenbench",
+                    "task": spec.key,
+                    "category": spec.category,
+                    "bimanual": spec.bimanual,
+                    "version": spec.version,
+                    "instance_id": inst.instance_id,
+                    "instance_index": index,
+                    "setup": inst.setup_spec(),
+                    "language_vars": list(inst.language_vars),
+                    "validation": _validation_dict(inst.validation),
+                },
+            )
+        )
+    return scenes
+
+
+def realize_scene(scene: Scene, seed: int | None) -> Realization:
+    """Recover the task instance behind a Scene and realize it for ``seed``.
+
+    The seam a real embodiment / operator tool uses to get the concrete setup for
+    a given realization. Recovery is by ``instance_id`` (stable across releases),
+    not by position — a scene logged under an older task set either resolves to
+    the same instance or fails loudly, never silently realizes a different one.
+    ``seed=None`` (direct ``reset(scene)`` calls) is guarded to ``0`` for
+    determinism.
+    """
+    key = str(scene.metadata["task"])
+    instance_id = str(scene.metadata["instance_id"])
+    for inst in SPEC_BY_KEY[key].instances:
+        if inst.instance_id == instance_id:
+            return inst.realize(seed if seed is not None else 0)
+    raise LookupError(f"no instance {instance_id!r} in task {key!r} (removed or renamed?)")
+
+
+def make_task(spec: TaskSpec) -> Task:
+    """Assemble a Inspect Robots :class:`~inspect_robots.Task` from a :class:`TaskSpec`."""
+    return Task(
+        name=f"kitchenbench/{spec.key}",
+        scenes=build_scenes(spec),
+        scorer=[task_success(), episode_length()],
+        max_steps=spec.max_steps,
+        epochs=Epochs(count=K_REALIZATIONS, reducer="mean"),
+        metadata={
+            "title": spec.title,
+            "category": spec.category,
+            "bimanual": spec.bimanual,
+            "version": spec.version,
+            "description": spec.description,
+            "k_instances": K_INSTANCES,
+            "k_realizations": K_REALIZATIONS,
+        },
+    )
+
+
+@task("kitchenbench/place_cutlery")
+def place_cutlery() -> Task:
+    return make_task(SPEC_BY_KEY["place_cutlery"])
+
+
+@task("kitchenbench/stack")
+def stack() -> Task:
+    return make_task(SPEC_BY_KEY["stack"])
+
+
+@task("kitchenbench/place_in_rack")
+def place_in_rack() -> Task:
+    return make_task(SPEC_BY_KEY["place_in_rack"])
+
+
+@task("kitchenbench/pour_pasta")
+def pour_pasta() -> Task:
+    return make_task(SPEC_BY_KEY["pour_pasta"])
+
+
+@task("kitchenbench/open_container")
+def open_container() -> Task:
+    return make_task(SPEC_BY_KEY["open_container"])
+
+
+@task("kitchenbench/fold_cloth")
+def fold_cloth() -> Task:
+    return make_task(SPEC_BY_KEY["fold_cloth"])
+
+
+@task("kitchenbench/seal_container")
+def seal_container() -> Task:
+    return make_task(SPEC_BY_KEY["seal_container"])
+
+
+@task("kitchenbench/handoff")
+def handoff() -> Task:
+    return make_task(SPEC_BY_KEY["handoff"])
+
+
+@task("kitchenbench/sort_cutlery")
+def sort_cutlery() -> Task:
+    return make_task(SPEC_BY_KEY["sort_cutlery"])
+
+
+@task("kitchenbench/scoop_pasta")
+def scoop_pasta() -> Task:
+    return make_task(SPEC_BY_KEY["scoop_pasta"])
+
+
+#: All task factories, keyed by their bare key (used by ``__init__`` + tests).
+TASK_FACTORIES = {
+    "place_cutlery": place_cutlery,
+    "stack": stack,
+    "place_in_rack": place_in_rack,
+    "pour_pasta": pour_pasta,
+    "open_container": open_container,
+    "fold_cloth": fold_cloth,
+    "seal_container": seal_container,
+    "handoff": handoff,
+    "sort_cutlery": sort_cutlery,
+    "scoop_pasta": scoop_pasta,
+}

kitchenbench-0.3.0.dist-info/METADATA

@@ -0,0 +1,273 @@
+Metadata-Version: 2.4
+Name: kitchenbench
+Version: 0.3.0
+Summary: A bimanual kitchen-manipulation benchmark for VLA models, built on Inspect Robots.
+Project-URL: Homepage, https://github.com/robocurve/kitchenbench
+Project-URL: Collection, https://github.com/robocurve/worldevals
+Project-URL: Framework, https://github.com/robocurve/inspect-robots
+Author: RoboCurve
+License-Expression: MIT
+License-File: LICENSE
+Keywords: benchmark,bimanual,kitchen,manipulation,robotics,vla
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: inspect-robots>=0.3
+Requires-Dist: numpy>=1.24
+Provides-Extra: dev
+Requires-Dist: mypy>=1.11; extra == 'dev'
+Requires-Dist: pre-commit>=3.5; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Description-Content-Type: text/markdown
+
+<div align="center">
+
+# 🍳 KitchenBench
+
+**A bimanual kitchen-manipulation benchmark for VLA models.**
+
+Built on [Inspect Robots](https://github.com/robocurve/inspect-robots) · part of
+[WorldEvals](https://github.com/robocurve/worldevals), the "Inspect Evals for robotics".
+
+[![CI](https://github.com/robocurve/kitchenbench/actions/workflows/ci.yml/badge.svg)](https://github.com/robocurve/kitchenbench/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green)](LICENSE)
+[![Coverage](https://img.shields.io/badge/coverage-100%25-brightgreen)](https://github.com/robocurve/kitchenbench/actions/workflows/ci.yml)
+[![Built on Inspect Robots](https://img.shields.io/badge/built%20on-Inspect%20Robots-indigo)](https://github.com/robocurve/inspect-robots)
+
+</div>
+
+KitchenBench is **10 kitchen-manipulation tasks** expressed as Inspect Robots `Task`s —
+embodiment-agnostic, so you run them against *any* compatible policy/embodiment.
+The set emphasizes **bimanual coordination**: pouring, lid removal, folding,
+part-mating, a pure two-arm handover, and tool-mediated scooping, alongside
+classic pick-place / stacking / slotted insertion and a multi-instance sort.
+
+It ships a **dependency-free mock kitchen** so the whole suite runs in CI, and is
+designed to point straight at real hardware — e.g. **YAM bimanual arms** driven by
+**MolmoAct2**.
+
+## The tasks
+
+| Task (`--task`) | Goal | Bimanual | Category |
+|---|---|:--:|---|
+| `kitchenbench/place_cutlery` | place the {cutlery} on the {dishware} | | pick-place |
+| `kitchenbench/stack` | stack the cups / bowls / plates | | stacking |
+| `kitchenbench/place_in_rack` | place the {dishware} into the dish rack | | insertion |
+| `kitchenbench/pour_pasta` | pour the dry pasta into the {vessel} | ✅ | granular |
+| `kitchenbench/open_container` | open the {container} | ✅ | articulated |
+| `kitchenbench/fold_cloth` | fold the {cloth} | ✅ | deformable |
+| `kitchenbench/seal_container` | seal the {container} with its lid | ✅ | mating |
+| `kitchenbench/handoff` | hand off the {item} from one arm to the other | ✅ | coordination |
+| `kitchenbench/sort_cutlery` | sort the cutlery into the correct tray compartments | | classification |
+| `kitchenbench/scoop_pasta` | scoop the {pasta} with the {tool} and transfer it to the container | ✅ | granular+tool |
+
+## Task instances & realizations
+
+KitchenBench follows the
+[physical-automation methodology](https://github.com/jeqcho/physical-automation-methodology-docs).
+The key ideas, top-down:
+
+- A **task** (e.g. `pour_pasta`) is a set of **task instances**.
+- A **task instance** is one concrete *scenario written as a distribution*: a
+  **stochastic setup** (named random variables, each with a distribution) plus a
+  **goal** (a natural-language success criterion that may reference the sampled
+  variables). It is *not* a single fixed scene — it is a recipe for generating many.
+- A **realization** is one sample of that recipe: draw every random variable from
+  its distribution to get one concrete environment (and a concrete goal sentence).
+- Running a `(policy, embodiment)` pair on `K_realizations` realizations and
+  averaging the binary successes estimates the **instance success probability**
+  P̂[Yᵢ = 1].
+
+```
+task  pour_pasta
+ ├─ instance 1  (a distribution)  ──realize──▶  5 concrete environments  ──▶  P̂₁
+ ├─ instance 2  (a distribution)  ──realize──▶  5 concrete environments  ──▶  P̂₂
+ │  … 5 instances total …
+ └─ instance 5  (a distribution)  ──realize──▶  5 concrete environments  ──▶  P̂₅
+```
+
+KitchenBench uses the methodology's recommended defaults: **5 instances per task**
+(`K_INSTANCES`) and **5 realizations per instance** (`K_REALIZATIONS`).
+
+### A worked example
+
+This is one of `pour_pasta`'s five instances (from
+[`specs.py`](src/kitchenbench/specs.py), lightly reformatted):
+
+```python
+TaskInstance(
+    instance_id="pour_pasta/measuring-cup-to-bowl",
+    goal="pour the dry pasta into the {vessel}",       # {vessel} is sampled
+    setup={
+        "vessel":         Categorical(("bowl", "cup", "pot")),
+        "fill_g":         Uniform(80, 200),            # grams of pasta
+        "pour_height_cm": Uniform(8, 15),
+        "vessel_x_cm":    Normal(0.0, 3.0),            # placement jitter (cm)
+        "vessel_y_cm":    Normal(0.0, 3.0),
+    },
+    language_vars=("vessel",),
+    target_kind="pour_into",
+    static={"substance": "dry_pasta"},
+)
+```
+
+**Realizing it** with different seeds samples those distributions into concrete
+environments an operator can physically arrange (and a goal to give the VLA)
+(numbers rounded here for readability):
+
+```
+realize(seed=0)                          realize(seed=2)
+  Goal: pour the dry pasta into the bowl   Goal: pour the dry pasta into the cup
+  Setup:                                    Setup:
+    vessel        = bowl                      vessel        = cup
+    fill_g        = 156                        fill_g        = 111
+    pour_height_cm = 9.9                       pour_height_cm = 10.1
+    vessel_x_cm   = +0.3                        vessel_x_cm   = -7.3
+    vessel_y_cm   = -1.6                        vessel_y_cm   = +5.4
+```
+
+Inspect and realize instances from Python:
+
+```python
+from kitchenbench import SPEC_BY_KEY
+
+inst = SPEC_BY_KEY["pour_pasta"].instances[0]
+inst.setup_spec()
+# {'fill_g': 'Uniform[80, 200]', 'pour_height_cm': 'Uniform[8, 15]',
+#  'vessel': 'Categorical({bowl, cup, pot})', 'vessel_x_cm': 'N(0, 3²)', ...}
+
+r = inst.realize(seed=0)
+r.instruction     # 'pour the dry pasta into the bowl'
+r.values          # {'vessel': 'bowl', 'fill_g': 156.43…, 'pour_height_cm': 9.88…, …}  (JSON-native)
+r.setup_lines     # ('fill_g = 156.43…', 'pour_height_cm = 9.88…', 'vessel = bowl', …)
+```
+
+### How it maps to a run
+
+Each instance becomes one Inspect Robots `Scene`; the 5 realizations are the 5 **epochs**
+(`Epochs(count=5, reducer="mean")`), each seeded independently. Because the reducer
+is the mean, **each scene's reduced `task_success` is the instance success
+probability P̂[Yᵢ = 1]** — exactly the methodology's estimator:
+
+```python
+from inspect_robots import eval
+(log,) = eval("kitchenbench/pour_pasta", "kitchen_scripted", "kitchen")
+for s in log.samples:
+    print(s.scene_id, s.reduced["task_success"])   # one P̂ per instance
+```
+
+On real hardware an embodiment (or operator tool) calls `realize_scene(scene,
+seed)` to get the concrete setup to arrange — `Realization.setup_lines` is the
+"arrange this" checklist, and `Realization.instruction` is the goal fed to the VLA.
+
+**Distribution types** (in [`distributions.py`](src/kitchenbench/distributions.py)):
+`Uniform(a, b)` continuous · `Categorical((…), weights=None)` over a finite set ·
+`Normal(μ, σ)` Gaussian · `Constant(v)` fixed. Every sample is a builtin
+`float`/`int`/`str` (JSON-native), and `Categorical` preserves value types (an `int`
+category samples back as an `int`).
+
+> **Validation status — read before trusting the numbers.** The shipped instances
+> are **AI-authored drafts** (`Validation(source="opus-draft")`, `validated=False`).
+> The methodology's `K_i = 5` is the count *after* human validation — 3 experts
+> rating each instance on representativeness **and** quality, accepted only if both
+> are ≥ 4. Run that commissioning pipeline before relying on the instances; we do
+> **not** fabricate ratings. Also note `eval()`'s task-level
+> `metrics["task_success"]` is the *mean of P̂ over instances* — a convenience
+> aggregate, **not** a methodology output (the methodology sorts the per-instance P̂
+> into quantiles and fits the pTQ / automation-halvings curves).
+
+## Install
+
+```bash
+# Inspect Robots isn't on PyPI yet, so install both from GitHub (uv recommended):
+uv pip install "inspect-robots @ git+https://github.com/robocurve/inspect-robots@v0.3.0"
+uv pip install "kitchenbench @ git+https://github.com/robocurve/kitchenbench"
+```
+
+## Run it (mock kitchen, no hardware)
+
+KitchenBench registers a dependency-free mock embodiment (`kitchen`) and policies
+(`kitchen_scripted` / `kitchen_random` / `kitchen_noop`) via entry points:
+
+```bash
+inspect-robots list tasks                       # see all kitchenbench/* tasks
+inspect-robots run --task kitchenbench/pour_pasta --policy kitchen_scripted --embodiment kitchen
+```
+
+Or in Python:
+
+```python
+from inspect_robots import eval
+
+(log,) = eval("kitchenbench/open_container", "kitchen_scripted", "kitchen")
+# Per-instance success probability P̂[Yᵢ=1] lives in each sample's reduced score:
+for s in log.samples:
+    print(s.scene_id, s.reduced["task_success"])
+# log.results.metrics["task_success"] is the mean of P̂ over instances — a
+# convenience aggregate, NOT a methodology quantity (the methodology sorts P̂ into
+# quantiles and fits pTQ / automation-halvings; out of scope here).
+```
+
+The mock is abstract (it models *progress toward the scene goal*, like Inspect Robots's
+`CubePick`) — its job is to exercise the pipeline and give you a template. **In the
+mock, success depends only on the seeded goal direction, so the sampled setup
+distributions have no causal effect** (P̂ is degenerately 1.0 for the scripted
+oracle); the distribution *content* only bites on a real embodiment. The **value is
+the task definitions**, which run unchanged on a real robot.
+
+## Run it on real hardware (YAM arms + MolmoAct2)
+
+KitchenBench tasks are embodiment-agnostic. To evaluate on real **YAM bimanual
+arms** with **MolmoAct2**, provide two Inspect Robots components (e.g. in your own
+adapter package such as `robocurve/embodiments`):
+
+- a **`Policy`** wrapping MolmoAct2: `act(observation) -> ActionChunk` (the
+  scene's `instruction` is fed to the VLA verbatim);
+- an **`Embodiment`** for the YAM arms: `reset`/`step`/`close`, declaring its
+  action space (e.g. two 7-DoF arms + grippers) and cameras. Because there is no
+  privileged success oracle, the embodiment should turn the **operator's
+  confirmation** at episode end into `StepResult(terminated=True,
+  termination_reason="success")` (or set `record.operator_judgement`) —
+  KitchenBench's `task_success` scorer reads either. Declare the `"self_paced"`
+  capability and pace the control loop inside `step()`.
+
+```bash
+inspect-robots run --task kitchenbench/pour_pasta --policy molmoact2 --embodiment yam_arms
+```
+
+Inspect Robots checks `(policy, embodiment)` compatibility (action dims, semantics,
+camera/state keys) before any motion and writes an immutable `EvalLog`.
+
+## Development
+
+```bash
+uv venv && uv pip install -e ".[dev]"     # inspect_robots resolved from the v0.3.0 tag
+uv run pre-commit install
+uv run pytest --cov                        # 100% coverage required
+uv run ruff check . && uv run mypy
+```
+
+## Citation
+
+If you use KitchenBench in your research, please cite it:
+
+```bibtex
+@software{kitchenbench,
+  author  = {Robocurve},
+  title   = {KitchenBench: A bimanual kitchen-manipulation benchmark for VLA models},
+  year    = {2026},
+  url     = {https://github.com/robocurve/kitchenbench},
+  version = {0.3.0},
+  license = {MIT}
+}
+```
+
+## License
+
+[MIT](LICENSE)

kitchenbench-0.3.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+kitchenbench/CLAUDE.md,sha256=m0osDadTTON6oxz4TojcB7678wYLOYEKl29YpChkjYw,4891
+kitchenbench/__init__.py,sha256=AVrD5TzUPYAC4ZRcSS03fM9KbGQftlWAsNLCFlhHL-Q,2166
+kitchenbench/distributions.py,sha256=GFcOTgdqnSUWLGEhegtNo_dlmjpYRx1yHVTLThL_Mt8,3992
+kitchenbench/embodiment.py,sha256=zLVlFRrNAFnN8_1ethQsR_KzVejbZFK1f5DP-k6AoJQ,5327
+kitchenbench/instances.py,sha256=tYyuyG3Dqwmiv4o-KLYxqw71AVd23jIKW7Tox_TSnn0,3352
+kitchenbench/policies.py,sha256=ecA8R8ITDX8Rio9Fl7lx6I-YvERjqohFli-rUXhI4ZQ,3398
+kitchenbench/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kitchenbench/scoring.py,sha256=qvBjN1HYII9Zer_JMTjaOMDVqOE-H6THAlFbTnpa6U8,1454
+kitchenbench/specs.py,sha256=iZmQPGvpmOsFBkEHtclZYYu4w1dJLueovQRqQtfxXhA,22984
+kitchenbench/tasks.py,sha256=JdeQ00aMn7zbjlFs52yg-yRGkoKdyueeNVrgVtHGXWk,5833
+kitchenbench-0.3.0.dist-info/METADATA,sha256=EMptRr_HscTknBdjDZKmwKZ4knVxdP2sY7yVXlPtG-o,12294
+kitchenbench-0.3.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+kitchenbench-0.3.0.dist-info/entry_points.txt,sha256=g2yDnRT9agBRkx_3P28FbkrI8mp77UuyvNV-S_0fJfU,887
+kitchenbench-0.3.0.dist-info/licenses/LICENSE,sha256=NaimrZjfDyMR93d5rbHzWsYQ4UrnVsxgIXZui2UHFjU,1066
+kitchenbench-0.3.0.dist-info/RECORD,,

kitchenbench-0.3.0.dist-info/WHEEL

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

kitchenbench-0.3.0.dist-info/entry_points.txt

@@ -0,0 +1,19 @@
+[inspect_robots.embodiments]
+kitchen = kitchenbench.embodiment:KitchenEmbodiment
+
+[inspect_robots.policies]
+kitchen_noop = kitchenbench.policies:NoopKitchenPolicy
+kitchen_random = kitchenbench.policies:RandomKitchenPolicy
+kitchen_scripted = kitchenbench.policies:ScriptedKitchenPolicy
+
+[inspect_robots.tasks]
+kitchenbench/fold_cloth = kitchenbench.tasks:fold_cloth
+kitchenbench/handoff = kitchenbench.tasks:handoff
+kitchenbench/open_container = kitchenbench.tasks:open_container
+kitchenbench/place_cutlery = kitchenbench.tasks:place_cutlery
+kitchenbench/place_in_rack = kitchenbench.tasks:place_in_rack
+kitchenbench/pour_pasta = kitchenbench.tasks:pour_pasta
+kitchenbench/scoop_pasta = kitchenbench.tasks:scoop_pasta
+kitchenbench/seal_container = kitchenbench.tasks:seal_container
+kitchenbench/sort_cutlery = kitchenbench.tasks:sort_cutlery
+kitchenbench/stack = kitchenbench.tasks:stack

kitchenbench-0.3.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 robocurve
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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 OR COPYRIGHT HOLDERS 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.