isitright 0.1.0.dev0__py3-none-any.whl

isitright/__about__.py

@@ -0,0 +1,4 @@
+"""Package metadata kept independent from runtime imports."""
+
+__version__ = "0.1.0.dev0"
+

isitright/__init__.py

@@ -0,0 +1,34 @@
+"""Public package interface for isitright."""
+
+from isitright.__about__ import __version__
+from isitright.api import StageNotImplementedError, check, check_suite
+from isitright.models import (
+    AttributionStatus,
+    CaseResult,
+    CheckConfig,
+    ColumnComparisonPolicy,
+    EquivalenceStatus,
+    FailOnPolicy,
+    OrderingPolicy,
+    SuiteCase,
+    SuiteResult,
+    ValidityStatus,
+)
+
+__all__ = [
+    "AttributionStatus",
+    "CaseResult",
+    "CheckConfig",
+    "ColumnComparisonPolicy",
+    "EquivalenceStatus",
+    "FailOnPolicy",
+    "OrderingPolicy",
+    "StageNotImplementedError",
+    "SuiteCase",
+    "SuiteResult",
+    "ValidityStatus",
+    "__version__",
+    "check",
+    "check_suite",
+]
+

isitright/api.py

@@ -0,0 +1,46 @@
+"""Reserved public API for the future analysis engine."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from os import PathLike
+from pathlib import Path
+
+from isitright.models import CaseResult, CheckConfig, SuiteResult
+
+
+class StageNotImplementedError(RuntimeError):
+    """Raised when a post-Stage-0 capability is invoked."""
+
+
+def check(
+    *,
+    database: str | PathLike[str],
+    reference_sql: str,
+    candidate_sql: str,
+    question: str | None = None,
+    constraints_file: str | PathLike[str] | None = None,
+    config: CheckConfig | None = None,
+    validator: Callable[[Path], bool] | None = None,
+) -> CaseResult:
+    """Compare one SQL pair once the Stage 1+ engine is implemented."""
+    del database, reference_sql, candidate_sql, question, constraints_file, config, validator
+    raise StageNotImplementedError(
+        "check() is a Stage 1+ capability; Stage 0 defines its contract only"
+    )
+
+
+def check_suite(
+    *,
+    database: str | PathLike[str],
+    cases: str | PathLike[str],
+    constraints_file: str | PathLike[str] | None = None,
+    config: CheckConfig | None = None,
+    validator: Callable[[Path], bool] | None = None,
+) -> SuiteResult:
+    """Compare a JSONL suite once the Stage 3 engine is implemented."""
+    del database, cases, constraints_file, config, validator
+    raise StageNotImplementedError(
+        "check_suite() is a Stage 3 capability; Stage 0 defines its contract only"
+    )
+

isitright/cli.py

@@ -0,0 +1,105 @@
+"""Stage 0 command-line contract."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from isitright import __version__
+from isitright.api import StageNotImplementedError, check, check_suite
+from isitright.models import CheckConfig, FailOnPolicy
+
+EXIT_INTERNAL_ERROR = 1
+EXIT_INVALID_INPUT = 2
+EXIT_POLICY_TRIGGERED = 3
+
+app = typer.Typer(
+    name="isitright",
+    help="Generate evidence about text-to-SQL evaluation robustness.",
+    no_args_is_help=True,
+)
+
+
+def version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"isitright {__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version: Annotated[
+        bool | None,
+        typer.Option("--version", callback=version_callback, is_eager=True, help="Show version."),
+    ] = None,
+) -> None:
+    """Inspect the Stage 0 command surface."""
+    del version
+
+
+def _not_implemented(action: Callable[[], object]) -> None:
+    try:
+        action()
+    except StageNotImplementedError as error:
+        typer.echo(str(error), err=True)
+        raise typer.Exit(EXIT_INTERNAL_ERROR) from error
+
+
+@app.command("check")
+def check_command(
+    database: Annotated[Path, typer.Option(exists=True, dir_okay=False, readable=True)],
+    reference_sql: Annotated[Path, typer.Option("--reference", exists=True, dir_okay=False)],
+    candidate_sql: Annotated[Path, typer.Option("--candidate", exists=True, dir_okay=False)],
+    constraints: Annotated[
+        Path | None, typer.Option("--constraints", exists=True, dir_okay=False)
+    ] = None,
+    seed: Annotated[int, typer.Option()] = 0,
+    max_attempts: Annotated[int, typer.Option(min=1)] = 100,
+    timeout: Annotated[float, typer.Option(min=0.001)] = 30.0,
+    output_dir: Annotated[Path, typer.Option()] = Path("artifacts/check"),
+    fail_on: Annotated[FailOnPolicy, typer.Option()] = FailOnPolicy.NONE,
+) -> None:
+    """Analyze one reference/candidate pair (reserved for Stage 1+)."""
+    del output_dir, fail_on
+    _not_implemented(
+        lambda: check(
+            database=database,
+            reference_sql=reference_sql.read_text(encoding="utf-8"),
+            candidate_sql=candidate_sql.read_text(encoding="utf-8"),
+            constraints_file=constraints,
+            config=CheckConfig(seed=seed, max_attempts=max_attempts, timeout_seconds=timeout),
+        )
+    )
+
+
+@app.command("suite")
+def suite_command(
+    database: Annotated[Path, typer.Option(exists=True, dir_okay=False, readable=True)],
+    cases: Annotated[Path, typer.Option(exists=True, dir_okay=False, readable=True)],
+    constraints: Annotated[
+        Path | None, typer.Option("--constraints", exists=True, dir_okay=False)
+    ] = None,
+    seed: Annotated[int, typer.Option()] = 0,
+    max_attempts: Annotated[int, typer.Option(min=1)] = 100,
+    timeout: Annotated[float, typer.Option(min=0.001)] = 30.0,
+    output_dir: Annotated[Path, typer.Option()] = Path("artifacts/suite"),
+    fail_on: Annotated[FailOnPolicy, typer.Option()] = FailOnPolicy.NONE,
+) -> None:
+    """Analyze a JSONL evaluation suite (reserved for Stage 3)."""
+    del output_dir, fail_on
+    _not_implemented(
+        lambda: check_suite(
+            database=database,
+            cases=cases,
+            constraints_file=constraints,
+            config=CheckConfig(seed=seed, max_attempts=max_attempts, timeout_seconds=timeout),
+        )
+    )
+
+
+if __name__ == "__main__":
+    app()
+

isitright/models.py

@@ -0,0 +1,269 @@
+"""Versioned Stage 0 data contracts.
+
+These models describe evidence produced by later stages. They do not execute SQL.
+"""
+
+from __future__ import annotations
+
+import re
+from enum import StrEnum
+from typing import Any, Literal, Self
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
+
+SCHEMA_VERSION: Literal["0.1"] = "0.1"
+
+
+class ContractModel(BaseModel):
+    """Base class for closed, deterministic report contracts."""
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class EquivalenceStatus(StrEnum):
+    COUNTEREXAMPLE_FOUND = "COUNTEREXAMPLE_FOUND"
+    NOT_FOUND_WITHIN_BUDGET = "NOT_FOUND_WITHIN_BUDGET"
+    INCONCLUSIVE = "INCONCLUSIVE"
+    UNSUPPORTED = "UNSUPPORTED"
+
+
+class ValidityStatus(StrEnum):
+    DOMAIN_VALIDATED = "DOMAIN_VALIDATED"
+    SCHEMA_VALID_ONLY = "SCHEMA_VALID_ONLY"
+    INVALID = "INVALID"
+    UNKNOWN = "UNKNOWN"
+
+
+class AttributionStatus(StrEnum):
+    UNDETERMINED = "UNDETERMINED"
+    AGENT_DEFECT = "AGENT_DEFECT"
+    REFERENCE_DEFECT = "REFERENCE_DEFECT"
+    BOTH_DEFECTIVE = "BOTH_DEFECTIVE"
+    AMBIGUOUS_TASK = "AMBIGUOUS_TASK"
+
+
+class ColumnComparisonPolicy(StrEnum):
+    POSITIONAL = "positional"
+    BY_NAME = "by_name"
+    STRICT = "strict"
+
+
+class OrderingPolicy(StrEnum):
+    AUTO = "auto"
+    ORDERED = "ordered"
+    UNORDERED = "unordered"
+
+
+class FailOnPolicy(StrEnum):
+    NONE = "none"
+    DOMAIN_VALIDATED = "domain-validated"
+    ANY_COUNTEREXAMPLE = "any-counterexample"
+
+
+class SQLiteStorageClass(StrEnum):
+    NULL = "null"
+    INTEGER = "integer"
+    REAL = "real"
+    TEXT = "text"
+    BLOB = "blob"
+
+
+class CheckConfig(ContractModel):
+    """Deterministic controls shared by single-case and suite analysis."""
+
+    seed: int = 0
+    max_attempts: int = Field(default=100, ge=1)
+    timeout_seconds: float = Field(default=30.0, gt=0)
+    column_policy: ColumnComparisonPolicy = ColumnComparisonPolicy.POSITIONAL
+    ordering_policy: OrderingPolicy = OrderingPolicy.AUTO
+    float_relative_tolerance: float = Field(default=1e-9, ge=0)
+
+
+class SuiteCase(ContractModel):
+    """One JSONL input record; unknown fields are retained as metadata."""
+
+    case_id: str = Field(min_length=1)
+    reference_sql: str = Field(min_length=1)
+    candidate_sql: str = Field(min_length=1)
+    question: str | None = None
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+    @model_validator(mode="before")
+    @classmethod
+    def collect_extra_metadata(cls, value: Any) -> Any:
+        if not isinstance(value, dict):
+            return value
+        known = {"case_id", "reference_sql", "candidate_sql", "question", "metadata"}
+        result = dict(value)
+        metadata = dict(result.get("metadata") or {})
+        for key in list(result):
+            if key not in known:
+                metadata[key] = result.pop(key)
+        result["metadata"] = metadata
+        return result
+
+
+class ComparisonPolicy(ContractModel):
+    columns: ColumnComparisonPolicy = ColumnComparisonPolicy.POSITIONAL
+    ordering: OrderingPolicy = OrderingPolicy.AUTO
+    float_relative_tolerance: float = Field(default=1e-9, ge=0)
+    unordered_rows_are_multiset: Literal[True] = True
+
+
+class SQLiteValue(ContractModel):
+    """A JSON-safe value tagged with its SQLite storage class.
+
+    Blob values are base64-encoded strings. Booleans are intentionally not accepted
+    as integers because reports preserve the observed SQLite storage class.
+    """
+
+    storage_class: SQLiteStorageClass
+    value: int | float | str | None
+
+    @field_validator("value", mode="before")
+    @classmethod
+    def reject_boolean(cls, value: Any) -> Any:
+        if isinstance(value, bool):
+            raise ValueError("boolean is not a SQLite report value")
+        return value
+
+    @model_validator(mode="after")
+    def value_matches_storage_class(self) -> Self:
+        value = self.value
+        valid = {
+            SQLiteStorageClass.NULL: value is None,
+            SQLiteStorageClass.INTEGER: isinstance(value, int) and not isinstance(value, bool),
+            SQLiteStorageClass.REAL: isinstance(value, float),
+            SQLiteStorageClass.TEXT: isinstance(value, str),
+            SQLiteStorageClass.BLOB: isinstance(value, str),
+        }[self.storage_class]
+        if not valid:
+            raise ValueError(f"value does not match SQLite storage class {self.storage_class}")
+        return self
+
+
+class ResultColumn(ContractModel):
+    name: str
+
+
+class QueryResult(ContractModel):
+    columns: list[ResultColumn] = Field(default_factory=list)
+    rows: list[list[SQLiteValue]] = Field(default_factory=list)
+
+
+class InputHashes(ContractModel):
+    database_sha256: str
+    reference_sql_sha256: str
+    candidate_sql_sha256: str
+    constraints_sha256: str | None = None
+
+
+class CaseInputs(ContractModel):
+    database: str
+    reference_sql: str
+    candidate_sql: str
+    question: str | None = None
+    constraints_file: str | None = None
+    hashes: InputHashes
+
+
+class OriginalStateResult(ContractModel):
+    outputs_match: bool | None
+    reference_result: QueryResult | None = None
+    candidate_result: QueryResult | None = None
+    note: str | None = None
+
+
+class SearchAccounting(ContractModel):
+    seed: int
+    attempts: int = Field(ge=0)
+    admitted_states: int = Field(ge=0)
+    rejected_states: dict[str, int] = Field(default_factory=dict)
+    used_generators: list[str] = Field(default_factory=list)
+    skipped_generators: dict[str, str] = Field(default_factory=dict)
+    coverage_notes: list[str] = Field(default_factory=list)
+
+
+class CounterexampleEvidence(ContractModel):
+    generator: str
+    validity_status: ValidityStatus
+    reference_result: QueryResult
+    candidate_result: QueryResult
+    difference: str
+    reproducer_path: str
+    replay_command: str
+    original_injected_change: str
+    minimization_complete: bool
+
+
+class ErrorDetail(ContractModel):
+    code: str
+    message: str
+    phase: str
+
+
+class Timing(ContractModel):
+    elapsed_seconds: float = Field(ge=0)
+
+
+class CaseResult(ContractModel):
+    schema_version: Literal["0.1"] = SCHEMA_VERSION
+    case_id: str | None = None
+    equivalence_status: EquivalenceStatus
+    validity_status: ValidityStatus
+    attribution_status: AttributionStatus = AttributionStatus.UNDETERMINED
+    headline: str
+    inputs: CaseInputs
+    comparison_policy: ComparisonPolicy = Field(default_factory=ComparisonPolicy)
+    original_state: OriginalStateResult
+    search: SearchAccounting
+    assumptions: list[str] = Field(default_factory=list)
+    checked_rules: list[str] = Field(default_factory=list)
+    evidence: CounterexampleEvidence | None = None
+    errors: list[ErrorDetail] = Field(default_factory=list)
+    timing: Timing
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+    @field_validator("headline")
+    @classmethod
+    def headline_avoids_verdict_language(cls, value: str) -> str:
+        forbidden = re.compile(r"\b(pass|fail|correct|wrong)\b", re.IGNORECASE)
+        if forbidden.search(value):
+            raise ValueError("headline must describe evidence without verdict language")
+        return value
+
+
+class SuiteTotals(ContractModel):
+    cases: int = Field(ge=0)
+    by_equivalence_status: dict[EquivalenceStatus, int] = Field(default_factory=dict)
+    by_validity_status: dict[ValidityStatus, int] = Field(default_factory=dict)
+
+
+class SuiteResult(ContractModel):
+    schema_version: Literal["0.1"] = SCHEMA_VERSION
+    cases: list[CaseResult]
+    totals: SuiteTotals
+    mutator_family_totals: dict[str, int] = Field(default_factory=dict)
+    timing: Timing
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+    def ranked(self) -> list[CaseResult]:
+        """Return a stable evidence-priority ordering without mutating the suite."""
+
+        def priority(case: CaseResult) -> int:
+            if case.equivalence_status is EquivalenceStatus.COUNTEREXAMPLE_FOUND:
+                if case.validity_status is ValidityStatus.DOMAIN_VALIDATED:
+                    return 0
+                if case.validity_status is ValidityStatus.SCHEMA_VALID_ONLY:
+                    return 1
+            if case.equivalence_status in {
+                EquivalenceStatus.INCONCLUSIVE,
+                EquivalenceStatus.UNSUPPORTED,
+            }:
+                return 2
+            if case.equivalence_status is EquivalenceStatus.NOT_FOUND_WITHIN_BUDGET:
+                return 3
+            return 2
+
+        return sorted(self.cases, key=priority)
+

isitright/suite.py

@@ -0,0 +1,43 @@
+"""JSONL suite contract loading without executing cases."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Iterable
+from pathlib import Path
+
+from pydantic import ValidationError
+
+from isitright.models import SuiteCase
+
+
+class SuiteInputError(ValueError):
+    """A suite record is not valid under the v0.1 input contract."""
+
+
+def parse_suite_lines(lines: Iterable[str]) -> list[SuiteCase]:
+    """Parse nonblank JSONL records and report their one-based line numbers."""
+    cases: list[SuiteCase] = []
+    seen_ids: set[str] = set()
+    for line_number, line in enumerate(lines, start=1):
+        if not line.strip():
+            continue
+        try:
+            raw = json.loads(line)
+            case = SuiteCase.model_validate(raw)
+        except (json.JSONDecodeError, ValidationError) as error:
+            raise SuiteInputError(f"invalid suite record on line {line_number}: {error}") from error
+        if case.case_id in seen_ids:
+            raise SuiteInputError(
+                f"duplicate case_id {case.case_id!r} on line {line_number}"
+            )
+        seen_ids.add(case.case_id)
+        cases.append(case)
+    return cases
+
+
+def load_suite_cases(path: str | Path) -> list[SuiteCase]:
+    """Load a UTF-8 JSONL suite under the Stage 0 input contract."""
+    with Path(path).open(encoding="utf-8") as suite_file:
+        return parse_suite_lines(suite_file)
+

isitright-0.1.0.dev0.dist-info/METADATA

@@ -0,0 +1,105 @@
+Metadata-Version: 2.4
+Name: isitright
+Version: 0.1.0.dev0
+Summary: Evidence-first stress testing for text-to-SQL evaluations
+Project-URL: Repository, https://github.com/isitright-ai/isitright
+Author: isitright contributors
+License: MIT License
+        
+        Copyright (c) 2026 isitright contributors
+        
+        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.
+        
+License-File: LICENSE
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.11
+Requires-Dist: pydantic<3,>=2.10
+Requires-Dist: pyyaml<7,>=6.0.2
+Requires-Dist: sqlglot<29,>=27
+Requires-Dist: typer<1,>=0.15
+Provides-Extra: dev
+Requires-Dist: build<2,>=1.2.2; extra == 'dev'
+Requires-Dist: mypy<2,>=1.14; extra == 'dev'
+Requires-Dist: pytest-cov<8,>=6; extra == 'dev'
+Requires-Dist: pytest<9,>=8.3; extra == 'dev'
+Requires-Dist: ruff<1,>=0.9; extra == 'dev'
+Requires-Dist: twine<7,>=6.1; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# isitright
+
+`isitright` is an evidence-first tool for stress-testing text-to-SQL evaluations.
+Given reference and candidate SQL, the eventual v0.1 engine will search for a valid
+database state on which their outputs differ and emit a minimized, replayable
+counterexample. A disagreement is evidence, not automatic attribution of fault.
+
+## Current status: Stage 0 review gate
+
+This repository currently contains package scaffolding and specification contracts
+only. SQL execution, database mutation, constraint validation, search, comparison,
+and minimization are deliberately not implemented. The proposed fixtures under
+`tests/fixtures/proposals` require owner approval before Stage 1 begins.
+
+## Development
+
+Python 3.11 or newer is required. With `uv` installed:
+
+```console
+uv sync --extra dev
+uv run ruff check .
+uv run mypy src
+uv run pytest
+uv build
+```
+
+The package exposes the future command surface now:
+
+```console
+isitright --version
+isitright check --help
+isitright suite --help
+```
+
+Calling `check` or `suite` during Stage 0 exits with the internal/not-implemented
+code because no analysis engine exists yet.
+
+The Stage 0 preview is versioned `0.1.0.dev0`. It is intentionally a development
+release and must not be presented as an implemented analysis engine.
+
+## Contract highlights
+
+- Result statuses keep observed equivalence, state validity, and attribution separate.
+- Unordered query results will be compared as multisets, preserving duplicates.
+- Automatic ordering will honor a top-level `ORDER BY`; otherwise results are unordered.
+- SQLite values are represented with explicit storage classes.
+- Reports use schema version `0.1`; package versioning remains pre-release until an
+  engine is implemented.
+
+See [the contract reference](docs/contracts.md) and
+[the fixture proposal](tests/fixtures/proposals/README.md).
+
+## License
+
+MIT
+

isitright-0.1.0.dev0.dist-info/RECORD

@@ -0,0 +1,11 @@
+isitright/__about__.py,sha256=iNIRHlrBKAHdi2BELRNh4_PWDF2Qye6QR7JuMSluUD8,91
+isitright/__init__.py,sha256=hywgNdYYhi2kIEQ66i-FcKFA-SezQyemuNTnNenJYM8,708
+isitright/api.py,sha256=trhgccsxDSrXRj4x1GqMGD487F7XM0Y6nqeUWVzIpuM,1463
+isitright/cli.py,sha256=_wPoycaXVDQjqKAAt0oItTABAgTiWEz5IC-NSRYoTPE,3484
+isitright/models.py,sha256=CBrlkg_MobO9oycbl-ivQImq1ryh4DYxBxwIoGKeFOU,8441
+isitright/suite.py,sha256=yVvhUw_qz6VfkzKVM9gbOJTzUxF74nTDskgO_h0dGNA,1408
+isitright-0.1.0.dev0.dist-info/METADATA,sha256=nALCp31rVTM-_r0YHaUerRDGgntRpGp785jFx7wcuWs,4148
+isitright-0.1.0.dev0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+isitright-0.1.0.dev0.dist-info/entry_points.txt,sha256=hwNIxaD5JYnFWLfxVHEyxj6M5bHJX48-82ofsREUsEA,48
+isitright-0.1.0.dev0.dist-info/licenses/LICENSE,sha256=iHif5Dqqe1AlWATTIzsiRxsIOf1Z0Fe08ZVb1PqQmow,1080
+isitright-0.1.0.dev0.dist-info/RECORD,,

isitright-0.1.0.dev0.dist-info/WHEEL

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

isitright-0.1.0.dev0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+isitright = isitright.cli:app

isitright-0.1.0.dev0.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 isitright contributors
+
+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.
+