semantic-operators 0.1.0__py3-none-any.whl

semantic_operators/__init__.py

@@ -0,0 +1,6 @@
+"""Semantic Operators: one small interface for System One models."""
+
+from .provider import AsyncProvider, Provider
+from .types import Answer, Boolean, Choice, Question, Score, State
+
+__all__ = ["Answer", "AsyncProvider", "Boolean", "Choice", "Provider", "Question", "Score", "State"]

semantic_operators/bench.py

@@ -0,0 +1,172 @@
+"""A tiny benchmark: run labeled cases through a provider and score the answers.
+
+Higher layer: built only on the base layer (types + Provider).
+
+For each question we report:
+- accuracy:   how often the provider's decision matches the label.
+- p(correct): the average probability the provider gave the labeled answer.
+              Two providers can be equally accurate while one is far more sure
+              of itself when it's right (and, worse, when it's wrong).
+
+``run_async`` is ``run`` for an ``AsyncProvider``, with up to ``concurrency``
+calls in flight at once.
+
+``stability`` compares runs of differently worded versions of the same
+questions: how often does the decision stay the same when only the wording changes?
+"""
+
+import asyncio
+import statistics
+import time
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass, field
+
+from .provider import AsyncProvider, Provider
+from .types import Answer, Boolean, Choice, Question, Score, State
+
+# A decision is an answer reduced to one discrete label:
+# a bool for Boolean, an option name for Choice, a level index (0, 1, ...) for Score.
+Decision = bool | str | int
+
+
+@dataclass(frozen=True)
+class Case:
+    """One labeled input. ``expected`` maps question name -> the correct decision.
+
+    Score labels are level indexes, not level text, so the same labels still apply
+    when the rubric is reworded.
+    """
+
+    state: State
+    expected: dict[str, Decision]
+
+
+@dataclass
+class QuestionStats:
+    correct: int = 0
+    total: int = 0
+    p_correct: list[float] = field(default_factory=list)
+
+    @property
+    def accuracy(self) -> float:
+        return self.correct / self.total if self.total else 0.0
+
+    @property
+    def mean_p_correct(self) -> float:
+        return statistics.fmean(self.p_correct) if self.p_correct else 0.0
+
+
+@dataclass
+class Miss:
+    case: int
+    question: str
+    expected: Decision
+    got: Answer
+
+
+@dataclass
+class Report:
+    questions: dict[str, QuestionStats]
+    latencies_ms: list[float]  # per call
+    total_ms: float            # wall-clock time for all cases (excludes warm-up)
+    misses: list[Miss]
+    decisions: list[dict[str, Decision]]  # per case, per question
+
+
+def decide(question: Question, answer: Answer) -> Decision:
+    """Reduce an answer to a discrete decision (Score: round half up to a level index)."""
+    match question:
+        case Boolean() | Choice():
+            return answer.value
+        case Score():
+            return int(float(answer.value) + 0.5)
+
+
+def run(provider: Provider, questions: Mapping[str, Question], cases: Sequence[Case],
+        warmup: int = 1) -> Report:
+    """Ask every case's state all ``questions`` in one call per case.
+
+    The first ``warmup`` cases are also run once beforehand, untimed, so one-time
+    setup (loading, connecting) doesn't count as latency.
+    """
+    for case in cases[:warmup]:
+        provider.ask(case.state, questions)
+
+    answers: list[dict[str, Answer]] = []
+    latencies: list[float] = []
+    begin = time.perf_counter()
+    for case in cases:
+        start = time.perf_counter()
+        answers.append(provider.ask(case.state, questions))
+        latencies.append((time.perf_counter() - start) * 1000)
+    total = (time.perf_counter() - begin) * 1000
+    return score(questions, cases, answers, latencies, total)
+
+
+async def run_async(provider: AsyncProvider, questions: Mapping[str, Question],
+                    cases: Sequence[Case], warmup: int = 1, concurrency: int = 4) -> Report:
+    """Like ``run``, but with up to ``concurrency`` calls in flight at once.
+
+    Per-call latency is measured from when a call gets a concurrency slot. It still
+    includes any queueing inside the provider (``AsyncLaya`` runs one call at a time),
+    so under concurrency it measures what a caller waits, not model speed.
+    ``total_ms`` shows the throughput gain, if any.
+    """
+    for case in cases[:warmup]:
+        await provider.ask(case.state, questions)
+
+    slots = asyncio.Semaphore(concurrency)
+
+    async def one(case: Case) -> tuple[dict[str, Answer], float]:
+        async with slots:
+            start = time.perf_counter()
+            answers = await provider.ask(case.state, questions)
+            return answers, (time.perf_counter() - start) * 1000
+
+    begin = time.perf_counter()
+    results = await asyncio.gather(*(one(case) for case in cases))  # keeps case order
+    total = (time.perf_counter() - begin) * 1000
+    return score(questions, cases, [a for a, _ in results], [ms for _, ms in results], total)
+
+
+def score(questions: Mapping[str, Question], cases: Sequence[Case],
+          answers: Sequence[Mapping[str, Answer]], latencies_ms: list[float],
+          total_ms: float) -> Report:
+    """Score already-collected answers (one dict of answers per case) against the labels."""
+    stats = {name: QuestionStats() for name in questions}
+    misses: list[Miss] = []
+    decisions: list[dict[str, Decision]] = []
+    for i, (case, case_answers) in enumerate(zip(cases, answers, strict=True)):
+        decisions.append({name: decide(q, case_answers[name]) for name, q in questions.items()})
+        for name, label in case.expected.items():
+            answer, s = case_answers[name], stats[name]
+            ok = decisions[-1][name] == label
+            s.total += 1
+            s.correct += ok
+            s.p_correct.append(answer.probabilities[_key(questions[name], label)])
+            if not ok:
+                misses.append(Miss(i, name, label, answer))
+    return Report(stats, latencies_ms, total_ms, misses, decisions)
+
+
+def stability(reports: Sequence[Report]) -> dict[str, float]:
+    """Per question: the fraction of cases whose decision is identical in every report.
+
+    Pass reports from differently worded versions of the same questions. Labels play
+    no part: a model can be perfectly stable and consistently wrong.
+    """
+    names = reports[0].decisions[0].keys()
+    cases = range(len(reports[0].decisions))
+    return {name: sum(len({r.decisions[i][name] for r in reports}) == 1 for i in cases) / len(cases)
+            for name in names}
+
+
+def _key(question: Question, label: Decision) -> str:
+    # Answer.probabilities keys: "true"/"false", option names, or level text.
+    match question:
+        case Boolean():
+            return str(label).lower()
+        case Choice():
+            return str(label)
+        case Score():
+            return question.levels[int(label)]

semantic_operators/provider.py

@@ -0,0 +1,22 @@
+"""The provider interfaces: anything with this ``ask`` method is a provider.
+
+They're Protocols, so providers don't inherit from anything or register anywhere.
+``AsyncProvider`` is the same contract with ``ask`` awaited.
+"""
+
+from collections.abc import Mapping
+from typing import Protocol
+
+from .types import Answer, Question, State
+
+
+class Provider(Protocol):
+    def ask(self, state: State, questions: Mapping[str, Question]) -> dict[str, Answer]:
+        """Answer every named question about ``state``. Returns answers by the same names."""
+        ...
+
+
+class AsyncProvider(Protocol):
+    async def ask(self, state: State, questions: Mapping[str, Question]) -> dict[str, Answer]:
+        """Answer every named question about ``state``. Returns answers by the same names."""
+        ...

semantic_operators/providers/jev.py

@@ -0,0 +1,67 @@
+"""Jev, via the TypeSafe SDK (``pip install semantic-operators[jev]``).
+
+Translation only: our questions -> SDK questions, one ``system_one`` call,
+SDK answers -> our ``Answer``. You create and own the SDK client:
+``TypeSafeClient`` for ``Jev``, ``AsyncTypeSafeClient`` for ``AsyncJev``.
+"""
+
+from collections.abc import Mapping
+
+import typesafe_sdk as ts
+
+from ..types import Answer, Boolean, Choice, Question, Score, State
+
+
+class Jev:
+    def __init__(self, client: ts.TypeSafeClient, model: str = "jev-latest") -> None:
+        self.client = client
+        self.model = model
+
+    def ask(self, state: State, questions: Mapping[str, Question]) -> dict[str, Answer]:
+        response = self.client.system_one(
+            state=state,
+            questions={name: _to_jev(q) for name, q in questions.items()},
+            model=self.model,
+        )
+        return {name: _from_jev(q, response.answers[name]) for name, q in questions.items()}
+
+
+class AsyncJev:
+    def __init__(self, client: ts.AsyncTypeSafeClient, model: str = "jev-latest") -> None:
+        self.client = client
+        self.model = model
+
+    async def ask(self, state: State, questions: Mapping[str, Question]) -> dict[str, Answer]:
+        response = await self.client.system_one(
+            state=state,
+            questions={name: _to_jev(q) for name, q in questions.items()},
+            model=self.model,
+        )
+        return {name: _from_jev(q, response.answers[name]) for name, q in questions.items()}
+
+
+def _to_jev(question: Question) -> ts.Noul | ts.Choice | ts.Score:
+    match question:
+        case Boolean():
+            described = question.true is not None or question.false is not None
+            criteria = {"true": question.true, "false": question.false} if described else None
+            return ts.Noul(instructions=question.instructions, criteria=criteria)
+        case Choice():
+            return ts.Choice(instructions=question.instructions, criteria=dict(question.options))
+        case Score():
+            return ts.Score(instructions=question.instructions, criteria=list(question.levels))
+
+
+def _from_jev(question: Question, answer: ts.Answer) -> Answer:
+    match question:
+        case Boolean():
+            # Jev returns one number: the probability the answer is "true".
+            p = answer.noul
+            return Answer(value=p > 0.5, probabilities={"true": p, "false": 1 - p}, raw=answer)
+        case Choice():
+            probabilities = {option: answer.probabilities[option] for option in question.options}
+            return Answer(value=answer.choice, probabilities=probabilities, raw=answer)
+        case Score():
+            # Jev keys probabilities by level index (0, 1, 2...); we key them by level text.
+            probabilities = {level: answer.probabilities[i] for i, level in enumerate(question.levels)}
+            return Answer(value=answer.score, probabilities=probabilities, raw=answer)

semantic_operators/providers/laya.py

@@ -0,0 +1,69 @@
+"""Laya, the open-weight Jev-compatible model (``pip install semantic-operators[laya]``).
+
+Runs locally. You load the model with the ``laya`` package and pass it in:
+``laya.load("convaiinnovations/laya")`` for one checkpoint, or ``laya.Router()`` to
+pick a checkpoint by language. Both have the ``predict`` method used here.
+
+``AsyncLaya`` runs predictions in a worker thread so they don't block the event
+loop, one at a time (the model is a single local compute resource; Laya's own
+HTTP server serializes calls the same way).
+"""
+
+import asyncio
+from collections.abc import Mapping
+from typing import Any
+
+from ..types import Answer, Boolean, Choice, Question, Score, State
+
+
+class Laya:
+    def __init__(self, model: Any) -> None:
+        self.model = model
+
+    def ask(self, state: State, questions: Mapping[str, Question]) -> dict[str, Answer]:
+        result = self.model.predict(state, {name: _to_laya(q) for name, q in questions.items()})
+        answers = result["answers"]
+        return {name: _from_laya(q, answers[name]) for name, q in questions.items()}
+
+
+class AsyncLaya:
+    def __init__(self, model: Any) -> None:
+        self._laya = Laya(model)
+        self._lock = asyncio.Lock()
+
+    async def ask(self, state: State, questions: Mapping[str, Question]) -> dict[str, Answer]:
+        async with self._lock:
+            return await asyncio.to_thread(self._laya.ask, state, questions)
+
+
+# Laya takes and returns plain dicts in Jev's request/response shape.
+
+
+def _to_laya(question: Question) -> dict[str, Any]:
+    match question:
+        case Boolean():
+            q: dict[str, Any] = {"type": "noul", "instructions": question.instructions}
+            if question.true is not None or question.false is not None:
+                q["criteria"] = {"true": question.true, "false": question.false}
+            return q
+        case Choice():
+            return {"type": "choice", "instructions": question.instructions,
+                    "criteria": dict(question.options)}
+        case Score():
+            return {"type": "score", "instructions": question.instructions,
+                    "criteria": list(question.levels)}
+
+
+def _from_laya(question: Question, answer: dict[str, Any]) -> Answer:
+    match question:
+        case Boolean():
+            p = answer["noul"]
+            return Answer(value=p > 0.5, probabilities={"true": p, "false": 1 - p}, raw=answer)
+        case Choice():
+            probabilities = {option: answer["probabilities"][option] for option in question.options}
+            return Answer(value=answer["choice"], probabilities=probabilities, raw=answer)
+        case Score():
+            # Laya keys probabilities by level index as a string ("0", "1", ...).
+            probabilities = {level: answer["probabilities"][str(i)]
+                             for i, level in enumerate(question.levels)}
+            return Answer(value=answer["score"], probabilities=probabilities, raw=answer)

semantic_operators/types.py

@@ -0,0 +1,57 @@
+"""The three question types and the one answer type.
+
+These are our words, not any provider's. A provider translates them into
+its own API and translates its answers back into an ``Answer``.
+"""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+# What a question is asked about: text, or JSON-shaped data.
+State = str | dict[str, Any] | list[Any]
+
+
+@dataclass(frozen=True)
+class Boolean:
+    """A yes/no question. ``true``/``false`` optionally describe each outcome."""
+
+    instructions: str
+    true: str | None = None
+    false: str | None = None
+
+
+@dataclass(frozen=True)
+class Choice:
+    """Pick one of several named options. Maps option name -> description."""
+
+    instructions: str
+    options: dict[str, str | None]
+
+
+@dataclass(frozen=True)
+class Score:
+    """Rate on an ordered rubric. ``levels[0]`` is score 0, ``levels[1]`` is 1, ..."""
+
+    instructions: str
+    levels: list[str]
+
+
+Question = Boolean | Choice | Score
+
+
+@dataclass(frozen=True)
+class Answer:
+    """The answer to one question.
+
+    - Boolean: ``value`` is a bool; ``probabilities`` has keys "true" and "false".
+    - Choice:  ``value`` is the chosen option name; ``probabilities`` is keyed by option,
+               in the same order as the question's options.
+    - Score:   ``value`` is the expected score (a float, may fall between levels);
+               ``probabilities`` is keyed by level text, in level order.
+
+    ``raw`` is the provider's own answer object, for when you need more.
+    """
+
+    value: bool | str | float
+    probabilities: dict[str, float]
+    raw: Any = field(default=None, repr=False)

semantic_operators-0.1.0.dist-info/METADATA

@@ -0,0 +1,195 @@
+Metadata-Version: 2.5
+Name: semantic-operators
+Version: 0.1.0
+Summary: One small, provider-neutral interface for System One models (Jev, Laya, and compatibles).
+Project-URL: Homepage, https://github.com/jasonduncan/semantic-operators
+Project-URL: Source, https://github.com/jasonduncan/semantic-operators
+Project-URL: Issues, https://github.com/jasonduncan/semantic-operators/issues
+Author: Jason Duncan
+License-Expression: MIT
+License-File: LICENSE
+Keywords: benchmark,classification,jev,laya,llm,system-one,typesafe
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Provides-Extra: jev
+Requires-Dist: typesafe-sdk>=0.7.1; extra == 'jev'
+Provides-Extra: laya
+Requires-Dist: laya>=0.3.20; extra == 'laya'
+Description-Content-Type: text/markdown
+
+# Semantic Operators
+
+One small interface for **System One models**: fast models that answer structured
+questions about text or data with probabilities, not prose. [Jev](https://typesafe.ai)
+was the first; [Laya](https://huggingface.co/convaiinnovations/laya) is an open-weight,
+Jev-compatible alternative you can run locally. More are coming. This library lets you
+write your code once and swap the model underneath.
+
+| Provider | Where it runs | Install |
+|----------|---------------|---------|
+| `providers.jev.Jev`   | TypeSafe's hosted API (needs `TYPESAFE_API_KEY`) | `[jev]`  |
+| `providers.laya.Laya` | on your machine (~800 MB download on first use)  | `[laya]` |
+
+## Install
+
+```sh
+pip install "semantic-operators[jev]"        # Jev (hosted)
+pip install "semantic-operators[laya]"       # Laya (local; pulls in torch)
+pip install "semantic-operators[jev,laya]"   # both
+```
+
+The core alone (`pip install semantic-operators`) has no dependencies.
+
+## The whole idea
+
+A System One model is asked **named questions about a piece of state** and returns an
+answer with probabilities for each. There are three kinds of question:
+
+| Question  | You give it                                   | `answer.value`                       |
+|-----------|-----------------------------------------------|--------------------------------------|
+| `Boolean` | instructions (+ optional true/false meanings) | `True` / `False`                     |
+| `Choice`  | instructions + named options                  | the chosen option name               |
+| `Score`   | instructions + ordered rubric levels          | expected level as a float, e.g. `1.7` |
+
+Every `Answer` also carries `probabilities` (a dict, in the question's option/level
+order) and `raw` (the provider's own answer object).
+
+A **provider** is anything with one method:
+
+```python
+def ask(self, state, questions: dict[str, Question]) -> dict[str, Answer]
+```
+
+That's the entire abstraction.
+
+## Quick start
+
+```sh
+echo "TYPESAFE_API_KEY=..." > .env
+uv run --env-file .env --extra jev python examples/hello.py
+```
+
+```python
+from typesafe_sdk import TypeSafeClient
+from semantic_operators import Boolean, Choice, Score
+from semantic_operators.providers.jev import Jev
+
+with TypeSafeClient() as client:          # you create and own the SDK client
+    jev = Jev(client)                     # model defaults to "jev-latest"
+    answers = jev.ask(
+        "I was charged twice and I'm furious.",
+        {
+            "is_complaint": Boolean("Is the customer complaining?"),
+            "department": Choice("Which team should handle this?",
+                                 {"billing": "Payments, refunds", "other": "Anything else"}),
+            "urgency": Score("How urgent is this?", ["low", "medium", "high"]),
+        },
+    )
+
+answers["department"].value           # "billing"
+answers["department"].probabilities   # {"billing": 0.97, "other": 0.03}
+```
+
+Swapping to Laya changes only how the provider is built:
+
+```python
+import laya
+from semantic_operators.providers.laya import Laya
+
+provider = Laya(laya.load("convaiinnovations/laya"))   # or Laya(laya.Router())
+answers = provider.ask(state, questions)                # same questions, same Answer type
+```
+
+Compare both side by side:
+
+```sh
+uv run --env-file .env --extra jev --extra laya python examples/compare.py
+```
+
+## Benchmark
+
+`bench.run(provider, questions, cases)` asks each labeled case all questions in one call
+and reports, per question, **accuracy** (Score values are rounded to the nearest level)
+and **p(correct)**, the average probability the provider gave the right answer, plus
+latency and every miss.
+
+```sh
+uv run --env-file .env --extra jev --extra laya python benchmarks/run.py
+```
+
+`benchmarks/support_tickets.py` holds 20 hand-written, hand-labeled support messages
+and the same 3 questions in three wordings. `bench.stability(reports)` reports how often
+a provider's decision stays the same when only the wording changes (labels play no part). It's a smoke test, not a verdict: small, authored, one person's labels.
+
+## Async
+
+Every provider has an async twin with the same contract, `await provider.ask(...)`:
+
+```python
+from typesafe_sdk import AsyncTypeSafeClient
+from semantic_operators.providers.jev import AsyncJev
+from semantic_operators.providers.laya import AsyncLaya
+
+async with AsyncTypeSafeClient() as client:
+    answers = await AsyncJev(client).ask(state, questions)
+```
+
+`AsyncLaya` runs the local model in a worker thread, one call at a time. Concurrency
+speeds up a hosted API (many requests in flight), not a single local model.
+`bench.run_async(provider, questions, cases, concurrency=8)` benchmarks async providers:
+
+```sh
+uv run --env-file .env --extra jev --extra laya python benchmarks/run_async.py
+```
+
+## Layout
+
+```
+src/semantic_operators/
+  types.py          Boolean, Choice, Score, Answer: our vocabulary
+  provider.py       Provider and AsyncProvider (one method each)
+  providers/jev.py  translates to/from the TypeSafe SDK
+  providers/laya.py translates to/from the laya package
+  bench.py          (higher layer) run labeled cases through a provider, score them
+examples/
+  hello.py          one real call to Jev
+  compare.py        the same questions through Jev and Laya
+benchmarks/
+  support_tickets.py  20 labeled messages + the questions
+  run.py              runs the suite through Jev and Laya
+  run_async.py        concurrency, and both providers at once
+```
+
+## Layers
+
+Semantic Operators is built in layers inside one package:
+
+1. **Base layer:** a clean, provider-neutral abstraction over System One
+   models: `types.py`, `provider.py`, `providers/`.
+2. **Higher layers:** built only on the base layer. So far: `bench.py`. Later: reusable
+   named operators and composition.
+
+The base layer never imports from a higher layer, so it could later be split out as its
+own package without changing how it's used.
+
+## Rules
+
+- The library never reads API keys or environment variables. You build the client.
+- The core has no dependencies. Each provider's SDK is an optional extra (`[jev]`, `[laya]`).
+- Our names, not the provider's: `Boolean`, not `noul`.
+
+## Not here yet (on purpose)
+
+Reusable named operators, error types, and
+"don't know" answers. Each will be added as its own small step.
+
+## License
+
+MIT

semantic_operators-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+semantic_operators/__init__.py,sha256=qr16WoMff280u5FNF1tVlSIY2Nd1fJT5sye6PAP9tBg,285
+semantic_operators/bench.py,sha256=fV5yB5UA496OHfoBntbPYs4cQBJpbvnzq39XP9XfuOw,6439
+semantic_operators/provider.py,sha256=qoq0Zedo4NVb6g5o5iYPqL_gJgUNvc25Fo9EBRJ3c2Y,791
+semantic_operators/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+semantic_operators/types.py,sha256=4aYTGjWYx1jx8ars31yPCY64rBa-vN4BUN8rUmpu8tc,1612
+semantic_operators/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+semantic_operators/providers/jev.py,sha256=Da1sOjMjJyAQnbo-DpLC7T-QeqZyBOTz_r0eAmtiLmc,2923
+semantic_operators/providers/laya.py,sha256=i7rH8D565GEXxeH49HPc7Y8nx3Rh3OruInkDJneF9ks,2939
+semantic_operators-0.1.0.dist-info/METADATA,sha256=XE8irLsHuHedFsOWtxTh3fbjYfy7yHw3uQRv2FhXZoo,7397
+semantic_operators-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+semantic_operators-0.1.0.dist-info/licenses/LICENSE,sha256=Xndu7f16mot0SJ4RVZ45Ho_2qqezkHHStDHIaUkSJrQ,1069
+semantic_operators-0.1.0.dist-info/RECORD,,

semantic_operators-0.1.0.dist-info/WHEEL

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

semantic_operators-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jason Duncan
+
+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.