klix-engine 0.1.0__py3-none-any.whl

klix/__init__.py

@@ -0,0 +1,15 @@
+"""Klix: Entkoppelte Entscheidungs-Köpfe (Choice, Score, Flag) auf einem geteilten semantischen Backbone."""
+
+from klix.engine import DecisionEngine, DecisionResult
+from klix.heads import BaseHead, Choice, Flag, Score
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "DecisionEngine",
+    "DecisionResult",
+    "BaseHead",
+    "Choice",
+    "Score",
+    "Flag",
+]

klix/backbone.py

@@ -0,0 +1,64 @@
+"""Geteilte Feature-Extraktion: ein Text geht genau einmal dense + sparse transformiert rein."""
+
+from dataclasses import dataclass
+from typing import Any
+
+import numpy as np
+from fastembed import TextEmbedding
+from sklearn.feature_extraction.text import TfidfVectorizer
+
+# Kompakte deutsche Stoppwortliste (bewusst klein, damit Fachbegriffe ihre
+# Information behalten; erweiterbar via build_vocabulary(..., stop_words=...)).
+_DEFAULT_GERMAN_STOPWORDS = [
+    "die", "der", "das", "ein", "eine", "einer", "eines", "einem", "einen",
+    "im", "in", "ist", "und", "für", "von", "mit", "an", "auf", "nach", "zu",
+    "nicht", "mehr", "wird", "wie", "was", "hier", "dort",
+]
+
+
+@dataclass
+class EncodedInput:
+    """Ergebnis der einmaligen Feature-Extraktion für einen Eingabetext."""
+
+    text: str
+    dense_vec: np.ndarray  # normalisierter Dense-Vektor (MiniLM, 384 dim)
+    sparse_vec: Any  # TF-IDF Sparse-Matrix (1 x V) oder None vor compile()
+
+
+class HybridBackbone:
+    """Kapselt Dense- (FastEmbed) und Sparse- (TF-IDF) Repräsentation eines Texts.
+
+    Wird von der Engine genau einmal instanziiert. Der Text wird pro `decide()`-Aufruf
+    genau einmal encoded; alle Köpfe arbeiten anschließend auf `EncodedInput`.
+    """
+
+    def __init__(self, model_name: str = "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"):
+        self.embed_model = TextEmbedding(model_name=model_name)
+        self.tfidf_vec: TfidfVectorizer | None = None
+        self.is_indexed = False
+
+    def build_vocabulary(
+        self,
+        all_texts: list[str],
+        stop_words: list[str] | None = None,
+    ) -> None:
+        """Baut den Sparse-Index über alle in den Köpfen hinterlegten Referenztexte auf."""
+        if stop_words is None:
+            stop_words = _DEFAULT_GERMAN_STOPWORDS
+        self.tfidf_vec = TfidfVectorizer(
+            analyzer="word",
+            token_pattern=r"(?u)\b[\w-]+\b",
+            lowercase=True,
+            stop_words=stop_words,
+        )
+        self.tfidf_vec.fit(all_texts)
+        self.is_indexed = True
+
+    def encode(self, text: str) -> EncodedInput:
+        """Erzeugt beide Vektoren in einem Rutsch."""
+        vec = np.array(list(self.embed_model.embed([text]))[0])
+        norm = float(np.linalg.norm(vec))
+        dense_norm = vec / (norm if norm > 0 else 1.0)
+
+        sparse = self.tfidf_vec.transform([text]) if self.is_indexed else None
+        return EncodedInput(text=text, dense_vec=dense_norm, sparse_vec=sparse)

klix/engine.py

@@ -0,0 +1,83 @@
+"""Die Orchestrierungs-Engine: bindet Backbone und Köpfe zusammen."""
+
+import time
+
+from klix.backbone import HybridBackbone
+from klix.heads import BaseHead
+
+
+class DecisionResult:
+    """Ergebnis eines `decide()`-Aufrufs; Kopf-Werte als Attribute abrufbar."""
+
+    def __init__(self, text: str, latency_ms: float, head_data: dict):
+        self.text = text
+        self.latency_ms = latency_ms
+        self.data = head_data
+
+    def __getattr__(self, name: str):
+        if name in self.data:
+            return self.data[name]["value"]
+        raise AttributeError(f"Kopf '{name}' existiert nicht im Ergebnis.")
+
+    def details(self, name: str) -> dict:
+        """Vollständiges Ergebnis-Dict eines einzelnen Kopfs."""
+        return self.data.get(name, {})
+
+    def __repr__(self):
+        items = [f"{key}={value['value']}" for key, value in self.data.items()]
+        return f"<DecisionResult ({self.latency_ms:.1f}ms): {', '.join(items)}>"
+
+
+class DecisionEngine:
+    """Shared-Backbone-Engine mit beliebig vielen entkoppelten Köpfen.
+
+    Der Text wird pro `decide()` genau einmal encoded; alle Köpfe evaluieren
+    danach parallel auf denselben Vektoren.
+    """
+
+    def __init__(self, model_name: str = "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"):
+        self.backbone = HybridBackbone(model_name=model_name)
+        self.heads: list[BaseHead] = []
+        self._compiled = False
+
+    def add_head(self, head: BaseHead) -> "DecisionEngine":
+        """Registriert einen Kopf (fluent, verkettbar)."""
+        self.heads.append(head)
+        self._compiled = False
+        return self
+
+    def compile(self) -> None:
+        """Sammelt alle Texte aller Köpfe ein und initialisiert die Indizes."""
+        all_texts = []
+        for head in self.heads:
+            all_texts.extend(head.get_reference_texts())
+
+        if not all_texts:
+            raise ValueError("Keine Referenztexte vorhanden: erst Köpfe via add_head() registrieren.")
+
+        self.backbone.build_vocabulary(all_texts)
+
+        for head in self.heads:
+            head.fit(self.backbone)
+
+        self._compiled = True
+
+    def decide(self, text: str) -> DecisionResult:
+        """Encoded den Text einmal und evaluiert alle Köpfe auf den Vektoren."""
+        if not self.heads:
+            raise ValueError("Keine Köpfe registriert: erst add_head() aufrufen.")
+        if not self._compiled:
+            self.compile()
+
+        start = time.perf_counter()
+
+        # 1. Einmalige Vektorisierung (~10-12 ms).
+        encoded = self.backbone.encode(text)
+
+        # 2. Evaluation aller Köpfe (< 0.2 ms insgesamt).
+        results: dict[str, dict] = {}
+        for head in self.heads:
+            results[head.name] = head.evaluate(encoded)
+
+        elapsed_ms = (time.perf_counter() - start) * 1000
+        return DecisionResult(text=text, latency_ms=elapsed_ms, head_data=results)

klix/heads.py

@@ -0,0 +1,244 @@
+"""Die Entscheidungsköpfe: Choice (Routing), Score (Achse), Flag (Boolesch).
+
+Alle Köpfe arbeiten ausschließlich auf den vorberechneten Vektoren aus
+`EncodedInput` und sind dadurch voneinander entkoppelt.
+"""
+
+from abc import ABC, abstractmethod
+
+import numpy as np
+
+from klix.backbone import EncodedInput, HybridBackbone
+
+
+class BaseHead(ABC):
+    """Basisklasse für alle Köpfe.
+
+    Ein Kopf wird dreiphasig verwendet:
+    1. `get_reference_texts()` — sammelt Referenztexte für den TF-IDF-Index.
+    2. `fit(backbone)` — Vorberechnung aller Referenzvektoren (einmalig).
+    3. `evaluate(encoded)` — Bewertung pro Abfrage, < 0.1 ms Ziel.
+    """
+
+    def __init__(self, name: str):
+        self.name = name
+
+    @abstractmethod
+    def get_reference_texts(self) -> list[str]:
+        """Gibt alle Texte zurück, die der Backbone für den TF-IDF-Index kennen muss."""
+
+    @abstractmethod
+    def fit(self, backbone: HybridBackbone) -> None:
+        """Vorberechnung von Referenzvektoren."""
+
+    @abstractmethod
+    def evaluate(self, encoded: EncodedInput) -> dict:
+        """Berechnet das Ergebnis basierend auf den vorberechneten Vektoren."""
+
+
+def _normalize_rows(vectors: np.ndarray) -> np.ndarray:
+    """Zeilenweise auf Einheitslänge normieren (0-Vektoren bleiben 0)."""
+    norms = np.linalg.norm(vectors, axis=1, keepdims=True)
+    return vectors / np.where(norms == 0, 1.0, norms)
+
+
+class Choice(BaseHead):
+    """Klassifikation / Routing über Max-Similarity + Keyword-Boost.
+
+    Options-Label mit den meisten ähnlichen Beispielsätzen gewinnt. Die Sparse-
+    Ähnlichkeit (exakte Worttreffer, z. B. Asset-IDs wie `plc-34`) wird mit
+    `keyword_boost` auf die Dense-Ähnlichkeit addiert.
+    """
+
+    def __init__(self, name: str, options: dict[str, list[str]], keyword_boost: float = 0.5):
+        super().__init__(name)
+        self.options = options
+        self.keyword_boost = keyword_boost
+        self.flat_texts: list[str] = []
+        self.label_map: list[str] = []
+        self.dense_matrix: np.ndarray | None = None
+        self.sparse_matrix = None
+
+    def get_reference_texts(self) -> list[str]:
+        return [text for examples in self.options.values() for text in examples]
+
+    def fit(self, backbone: HybridBackbone) -> None:
+        self.flat_texts = []
+        self.label_map = []
+        for label, examples in self.options.items():
+            for example in examples:
+                self.flat_texts.append(example)
+                self.label_map.append(label)
+
+        vecs = np.array(list(backbone.embed_model.embed(self.flat_texts)))
+        self.dense_matrix = _normalize_rows(vecs)
+        self.sparse_matrix = backbone.tfidf_vec.transform(self.flat_texts)
+
+    def evaluate(self, encoded: EncodedInput) -> dict:
+        dense_sims = self.dense_matrix @ encoded.dense_vec
+
+        # Direkter Sparse-Dot statt sklearn cosine_similarity: TfidfVectorizer
+        # normiert beide Vektoren L2 (default norm="l2"), der Dot nicht-negativer
+        # Einheitsvektoren IST die Cosine-Aehnlichkeit — aber ~5x schneller
+        # (kein sklearn-Call-Overhead pro Abfrage).
+        sparse_sims = np.asarray((encoded.sparse_vec @ self.sparse_matrix.T).todense())[0]
+
+        hybrid_sims = dense_sims + self.keyword_boost * sparse_sims
+
+        # Pro Label die beste Beispiel-Ähnlichkeit behalten.
+        category_scores: dict[str, float] = {}
+        for idx, sim in enumerate(hybrid_sims):
+            label = self.label_map[idx]
+            if label not in category_scores or sim > category_scores[label]:
+                category_scores[label] = float(sim)
+
+        best_label = max(category_scores, key=category_scores.get)
+        best_score = category_scores[best_label]
+
+        # Margin zum Runner-Up als Konfidenzkalibrierung.
+        sorted_scores = sorted(category_scores.values(), reverse=True)
+        runner_up = sorted_scores[1] if len(sorted_scores) > 1 else 0.0
+        confidence = float(np.clip((best_score - runner_up) / (best_score + 1e-5) * 1.5, 0.0, 1.0))
+
+        return {
+            "value": best_label,
+            "score": best_score,
+            "confidence": confidence,
+            "scores": category_scores,
+        }
+
+
+class Score(BaseHead):
+    """Kontinuierliche Projektion auf eine semantische Achse.
+
+    Der Text wird gegen Low- und High-Anker similarity-gemessen; die Differenz
+    geht durch eine Sigmoid-Scherfunktion und wird auf [min_val, max_val] gemappt.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        low_anchors: list[str],
+        high_anchors: list[str],
+        min_val: float = 0.0,
+        max_val: float = 3.0,
+        sharpness: float = 8.0,
+    ):
+        super().__init__(name)
+        self.low_anchors = low_anchors
+        self.high_anchors = high_anchors
+        self.min_val = min_val
+        self.max_val = max_val
+        self.sharpness = sharpness
+        self.low_matrix: np.ndarray | None = None
+        self.high_matrix: np.ndarray | None = None
+
+    def get_reference_texts(self) -> list[str]:
+        return self.low_anchors + self.high_anchors
+
+    def fit(self, backbone: HybridBackbone) -> None:
+        low_v = np.array(list(backbone.embed_model.embed(self.low_anchors)))
+        self.low_matrix = _normalize_rows(low_v)
+
+        high_v = np.array(list(backbone.embed_model.embed(self.high_anchors)))
+        self.high_matrix = _normalize_rows(high_v)
+
+    def evaluate(self, encoded: EncodedInput) -> dict:
+        # Max-Similarity zu beiden Polen.
+        s_low = float(np.max(self.low_matrix @ encoded.dense_vec))
+        s_high = float(np.max(self.high_matrix @ encoded.dense_vec))
+
+        # Sigmoid-basierte Skalierung der Differenz.
+        diff = s_high - s_low
+        ratio = 1.0 / (1.0 + np.exp(-diff * self.sharpness))
+        calculated_score = self.min_val + ratio * (self.max_val - self.min_val)
+
+        return {
+            "value": round(float(calculated_score), 2),
+            "raw_diff": diff,
+        }
+
+
+class Flag(BaseHead):
+    """Boolesche Entscheidung mit kalibrierter Wahrscheinlichkeit.
+
+    Softmax über die Similarities zu True- und False-Ankern; Temperatur steuert
+    die Schärfe der Entscheidung.
+
+    Problem ohne drittes Pol: Bei Out-of-Domain-Texten sind beide Similarities
+    niedrig und nahe beieinander -> Wahrscheinlichkeit ~0.5 und Rauschen kippt
+    die Entscheidung. Mit `neutral_anchors` wird ein 3-Klassen-Softmax genutzt;
+    der Kopf liefert dann `value=None` (statt True/False), wenn "neutral"
+    gewinnt. Standardmäßig deaktiviert (klassisches 2-Klassen-Verhalten).
+    """
+
+    def __init__(
+        self,
+        name: str,
+        true_anchors: list[str],
+        false_anchors: list[str],
+        threshold: float = 0.5,
+        temp: float = 0.12,
+        neutral_anchors: list[str] | None = None,
+    ):
+        super().__init__(name)
+        self.true_anchors = true_anchors
+        self.false_anchors = false_anchors
+        self.threshold = threshold
+        self.temp = temp
+        self.neutral_anchors = neutral_anchors or []
+        self.true_matrix: np.ndarray | None = None
+        self.false_matrix: np.ndarray | None = None
+        self.neutral_matrix: np.ndarray | None = None
+
+    def get_reference_texts(self) -> list[str]:
+        return self.true_anchors + self.false_anchors + self.neutral_anchors
+
+    def fit(self, backbone: HybridBackbone) -> None:
+        t_v = np.array(list(backbone.embed_model.embed(self.true_anchors)))
+        self.true_matrix = _normalize_rows(t_v)
+
+        f_v = np.array(list(backbone.embed_model.embed(self.false_anchors)))
+        self.false_matrix = _normalize_rows(f_v)
+
+        if self.neutral_anchors:
+            n_v = np.array(list(backbone.embed_model.embed(self.neutral_anchors)))
+            self.neutral_matrix = _normalize_rows(n_v)
+        else:
+            self.neutral_matrix = None
+
+    def evaluate(self, encoded: EncodedInput) -> dict:
+        s_true = float(np.max(self.true_matrix @ encoded.dense_vec))
+        s_false = float(np.max(self.false_matrix @ encoded.dense_vec))
+
+        # Softmax über zwei (oder drei) Klassen mit Temperatur-Skalierung.
+        logits = np.array([s_true, s_false], dtype=float)
+        if self.neutral_matrix is not None:
+            s_neutral = float(np.max(self.neutral_matrix @ encoded.dense_vec))
+            logits = np.array([s_true, s_false, s_neutral], dtype=float)
+
+        scaled = logits / self.temp
+        scaled -= scaled.max()  # numerisch stabiler Softmax
+        exp = np.exp(scaled)
+        probs = exp / exp.sum()
+
+        if self.neutral_matrix is not None:
+            prob_true, prob_false, prob_neutral = (float(p) for p in probs)
+            if prob_neutral > max(prob_true, prob_false):
+                return {
+                    "value": None,
+                    "probability": prob_true,
+                    "probabilities": {"true": prob_true, "false": prob_false, "neutral": prob_neutral},
+                }
+            value = bool(prob_true >= self.threshold)
+            return {
+                "value": value,
+                "probability": prob_true,
+                "probabilities": {"true": prob_true, "false": prob_false, "neutral": prob_neutral},
+            }
+
+        prob = float(probs[0])
+        return {
+            "value": bool(prob >= self.threshold),
+            "probability": prob,
+        }

klix_engine-0.1.0.dist-info/METADATA

@@ -0,0 +1,146 @@
+Metadata-Version: 2.5
+Name: klix-engine
+Version: 0.1.0
+Summary: Entkoppelte Entscheidungs-Köpfe (Choice, Score, Flag) auf einem geteilten semantischen Backbone - lokal, deterministisch, ohne Modelltraining.
+Author: Max-Christoph Hänel
+License: MIT
+License-File: LICENSE
+Keywords: classification,decision-engine,embeddings,nlp,routing,semantic-search
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: German
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Requires-Dist: fastembed<1,>=0.3
+Requires-Dist: numpy>=1.24
+Requires-Dist: scikit-learn>=1.3
+Description-Content-Type: text/markdown
+
+# Klix
+
+Entkoppelte Entscheidungs-Köpfe auf einem geteilten semantischen Backbone.
+Ein Text geht **genau einmal** durch das Embedding-Modell (Dense + Sparse), beliebig viele
+Köpfe (`Choice`, `Score`, `Flag`) arbeiten anschließend auf den vorberechneten Vektoren –
+jeder in seinem eigenen mathematischen Raum. Kein Modelltraining, keine Slot-Limits,
+vollständig offline und CPU-only.
+
+## Architektur
+
+```text
+Text ──► HybridBackbone (FastEmbed-Dense + TF-IDF-Sparse, einmalig ~10 ms)
+              │
+              ├──► Choice   (Routing/Klassifikation: Max-Similarity + Keyword-Boost)
+              ├──► Score    (kontinuierliche Achse: Low/High-Anker + Sigmoid)
+              ├──► Flag     (Boolesch: 2/3-Klassen-Softmax mit Temperatur)
+              └──► eigene Köpfe (von BaseHead erben)
+```
+
+- **Shared Backbone:** Der Text wird einmal embedding + einmal TF-IDF transformiert.
+  3 Köpfe oder 50 Köpfe – die Extraktionskosten bleiben gleich.
+- **Entkoppelte Köpfe:** Neue Optionen in einem `Choice` beeinflussen weder `Score`- noch
+  `Flag`-Ergebnisse. Jeder Kopf kapselt seine eigene Logik.
+- **Deklarativ:** Nur Schemata mit Beispielsätzen definieren, `compile()`, fertig.
+
+## Installation
+
+```bash
+uv add klix-engine
+# oder
+pip install klix-engine
+```
+
+Beim ersten Aufruf lädt FastEmbed das Modell `paraphrase-multilingual-MiniLM-L12-v2`
+(~120 MB, einmalig, danach lokal gecacht). Danach läuft alles offline.
+
+## Schnellstart
+
+```python
+from klix import DecisionEngine, Choice, Score, Flag
+
+engine = DecisionEngine()
+
+engine.add_head(
+    Choice(
+        name="target",
+        options={
+            "it_ops": ["VPN abgerissen", "Server down", "Rechner bootet nicht"],
+            "ot_plant": ["Roboterzelle steht", "SPS Fehler", "Taktzeit deviation"],
+            "finance": ["KST 4210 über Budget", "Rechnung freigeben"],
+            "facility": ["Öllache Halle 2", "Heizung defekt"],
+        },
+    )
+)
+
+engine.add_head(
+    Score(
+        name="urgency",
+        low_anchors=["Routine-Wartung", "Informelle Frage"],
+        high_anchors=["Notfall sofort", "Produktionsstillstand", "Akute Gefahr"],
+        min_val=0.0,
+        max_val=3.0,
+    )
+)
+
+engine.add_head(
+    Flag(
+        name="is_security",
+        true_anchors=["Hackerangriff", "Ransomware Befall", "Datenabfluss"],
+        false_anchors=["Hardware kaputt", "Netzwerkstörung", "Alltägliche Anfrage"],
+        threshold=0.5,
+    )
+)
+
+engine.compile()
+
+res = engine.decide("plc-34 meldet fehler, förderband steht sofort!")
+
+print(res)                                   # <DecisionResult (11 ms): target=ot_plant, urgency=2.9, is_security=False>
+print(res.target)                            # 'ot_plant'
+print(res.urgency)                           # 2.87
+print(res.is_security)                       # False
+print(res.details("is_security"))            # {'value': False, 'probability': 0.03}
+```
+
+## Eigene Köpfe
+
+Von `BaseHead` erben und `evaluate(encoded)` implementieren:
+
+```python
+import re
+from klix import BaseHead
+
+class RegExExtractionHead(BaseHead):
+    def __init__(self, name: str, pattern: str):
+        super().__init__(name)
+        self.re = re.compile(pattern)
+
+    def get_reference_texts(self) -> list[str]:
+        return []  # keine Referenztexte nötig
+
+    def fit(self, backbone) -> None:
+        pass
+
+    def evaluate(self, encoded) -> dict:
+        match = self.re.search(encoded.text)
+        return {"value": match.group(0) if match else None}
+```
+
+## Entwicklung
+
+```bash
+uv sync          # Abhängigkeiten installieren
+uv run pytest    # Tests
+uv run python examples/demo.py
+uv build         # PyPI-Artefakte (wheel + sdist) nach dist/
+uv publish       # Hochladen (erfordert Token/Account)
+```
+
+## Lizenz
+
+MIT

klix_engine-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+klix/__init__.py,sha256=YXd4B5-tKilvsmm2SBFoFmKfB9D87TPc1egtgbdZtBs,355
+klix/backbone.py,sha256=fZH9gdr8PXcXWs1mnKweqtLVVThrArN5IrZakVDsK4c,2479
+klix/engine.py,sha256=H6YbYf41zAFd4PCwtwzrmSA98e5427BFbKOqtD_7KAk,2889
+klix/heads.py,sha256=QgkR9Gj5sw_L61jA2kjX8IsbUvlcArX-Jz8oax5lJ_o,9348
+klix_engine-0.1.0.dist-info/METADATA,sha256=3l7f2mt3KezDHjZFhuytfCyKOcp56x2sDlaCaJ6koho,4781
+klix_engine-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+klix_engine-0.1.0.dist-info/licenses/LICENSE,sha256=ExuIc59574ZQRqmBXXSY2AZrC8g4rzQ7syTDH6BKWvE,1076
+klix_engine-0.1.0.dist-info/RECORD,,

klix_engine-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

klix_engine-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Max-Christoph Hänel
+
+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.