matchpatch 0.4.0__py3-none-any.whl

matchpatch/progress.py

@@ -0,0 +1,39 @@
+"""Structured progress events shared by CLI workers and the GUI."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass
+from typing import Any
+
+
+@dataclass(frozen=True)
+class ProgressEvent:
+    kind: str
+    message: str | None = None
+    phase: str | None = None
+    preset_id: int | None = None
+    device_patch: str | None = None
+    preset_index: int | None = None
+    preset_total: int | None = None
+    snapshot: int | None = None
+    snapshot_total: int | None = None
+    reference_lufs: float | None = None
+    lufs: float | None = None
+    crest_factor_db: float | None = None
+    path: str | None = None
+
+    def to_json(self) -> str:
+        return json.dumps(asdict(self), separators=(",", ":"))
+
+    @classmethod
+    def from_json(cls, value: str) -> ProgressEvent:
+        payload: Any = json.loads(value)
+
+        if not isinstance(payload, dict):
+            raise ValueError("Progress event must be a JSON object")
+
+        try:
+            return cls(**payload)
+        except TypeError as exc:
+            raise ValueError(f"Invalid progress event: {exc}") from exc

matchpatch/workflow.py

@@ -0,0 +1,361 @@
+"""Reusable preset-normalization workflow shared by CLI and GUI front ends."""
+
+from __future__ import annotations
+
+import csv
+import shutil
+import tempfile
+from collections.abc import Callable
+from dataclasses import dataclass
+from dataclasses import replace as dataclass_replace
+from pathlib import Path
+
+from matchpatch.analysis import AnalysisOptions
+from matchpatch.custom_adjustments import load_custom_adjustments_file
+from matchpatch.devices import get_device_profile
+from matchpatch.devices.base import (
+    DeviceProfile,
+    NormalizationPolicy,
+    PatchFileAdjustments,
+    validate_snapshot_count,
+)
+from matchpatch.progress import ProgressEvent
+
+PROJECT_DIR = Path(__file__).resolve().parents[2]
+
+
+@dataclass(frozen=True)
+class ImportRequest:
+    kind: str
+    device_display_name: str
+    path: Path
+
+    @property
+    def message(self) -> str:
+        description = "measurement" if self.kind == "measurement" else "adjusted"
+        return (
+            f"Please import this {description} file into {self.device_display_name}:\n{self.path}"
+        )
+
+
+@dataclass(frozen=True)
+class NormalizationRequest:
+    device: str
+    input_path: Path
+    backend: str
+    windows_python: str
+    reference_di: Path
+    custom_adjustments_path: Path | None = None
+    output_path: Path | None = None
+    diff_input_path: Path | None = None
+    automation: bool = True
+    defer_export: bool = False
+    preset_set: str | None = None
+    limit: int | None = None
+    keep_temp: bool = False
+    ignore_bad_lufs: bool = True
+    target_lufs: float = -16.0
+    timeout: float | None = None
+    audio_device: str | int | None = None
+    sample_rate: int | None = None
+    input_mapping: str | None = None
+    output_mapping: str | None = None
+    blocksize: int | None = None
+    steering_output: str | None = None
+    steering_channel: int | None = None
+    preset_wait: float | None = None
+    snapshot_wait: float | None = None
+    measurement_wait: float | None = None
+    pre_roll: float | None = None
+    post_roll: float | None = None
+    round_trip_latency: float | None = None
+    simulate_fail_presets: str | None = None
+    play_recorded_output: bool = False
+    record_device_output: bool = False
+    playback_toggle_path: Path | None = None
+    recorded_output_dir: Path | None = None
+    snapshot_plan: tuple[tuple[str, tuple[int, ...]], ...] = ()
+    policy: NormalizationPolicy = NormalizationPolicy()
+    analysis_options: AnalysisOptions = AnalysisOptions()
+
+
+@dataclass(frozen=True)
+class NormalizationResult:
+    output_path: Path | None
+    temp_dir: Path | None
+    retained_csv_path: Path | None = None
+
+
+ProgressCallback = Callable[[ProgressEvent], None]
+ConfirmationCallback = Callable[[ImportRequest], bool]
+AnalysisRunner = Callable[[NormalizationRequest, list[int], Path, ProgressCallback | None], None]
+ProfileProvider = Callable[[str], DeviceProfile]
+TempDirFactory = Callable[[], Path]
+
+
+def normalize_presets(
+    request: NormalizationRequest,
+    *,
+    run_analysis: AnalysisRunner,
+    on_progress: ProgressCallback | None = None,
+    confirm_import: ConfirmationCallback | None = None,
+    get_profile: ProfileProvider = get_device_profile,
+    make_temp_dir: TempDirFactory | None = None,
+) -> NormalizationResult:
+    profile = get_profile(request.device)
+    validate_snapshot_count(profile, request.policy.snapshot_count)
+    handler = profile.create_patch_file_handler(PROJECT_DIR)
+    log_setter = getattr(handler, "set_log_callback", None)
+    if log_setter is not None:
+        log_setter(lambda message: _emit(on_progress, ProgressEvent("log", message=message)))
+    input_path = request.input_path.resolve()
+    handler.validate_input(input_path)
+
+    if not request.reference_di.is_file():
+        raise ValueError(f"Reference DI WAV does not exist: {request.reference_di}")
+    _validate_custom_adjustments(request)
+
+    if request.automation:
+        if request.output_path is not None:
+            raise ValueError("--output must not be specified with --automation")
+
+        measurement_path = handler.automation_output_path(input_path, "_measurement")
+        output_path = (
+            None
+            if request.defer_export
+            else handler.automation_output_path(input_path, "_adjusted")
+        )
+        _emit(on_progress, ProgressEvent("phase", phase="preparing_measurement"))
+        handler.create_measurement_file(input_path, measurement_path)
+        _emit(on_progress, ProgressEvent("phase", phase="waiting_for_measurement_import"))
+        _confirm(
+            confirm_import,
+            ImportRequest("measurement", profile.display_name, measurement_path),
+        )
+    else:
+        if request.output_path is None:
+            raise ValueError("--output is required unless --automation is used")
+
+        output_path = request.output_path.resolve()
+        handler.validate_output(input_path, output_path)
+
+    requested_ids = (
+        handler.parse_patch_set(request.preset_set) if request.preset_set is not None else None
+    )
+    assignments = handler.list_assignments(input_path)
+    preset_ids = handler.select_preset_ids(input_path, assignments, requested_ids)
+
+    snapshot_plan = request.snapshot_plan
+    if request.diff_input_path is not None:
+        previous_input_path = request.diff_input_path.resolve()
+        if previous_input_path.suffix.lower() != input_path.suffix.lower():
+            raise ValueError("--diff-input must use the same file type as --input")
+        diff_snapshot_ids = getattr(handler, "diff_snapshot_ids", None)
+        if diff_snapshot_ids is None:
+            diff_snapshots = {
+                preset_id: tuple(range(1, request.policy.snapshot_count + 1))
+                for preset_id in handler.diff_preset_ids(input_path, previous_input_path)
+            }
+        else:
+            diff_snapshots = diff_snapshot_ids(
+                input_path,
+                previous_input_path,
+                request.policy.snapshot_count,
+            )
+        diff_ids = set(diff_snapshots)
+        preset_ids = [preset_id for preset_id in preset_ids if preset_id in diff_ids]
+        snapshot_plan = _intersect_snapshot_plans(
+            snapshot_plan,
+            tuple(
+                (handler.format_patch_id(preset_id), diff_snapshots[preset_id])
+                for preset_id in preset_ids
+            ),
+        )
+
+    if request.limit is not None:
+        if request.limit < 1:
+            raise ValueError("--limit must be at least 1")
+
+        preset_ids = preset_ids[: request.limit]
+
+    if not preset_ids:
+        raise ValueError("Patch file contains no measurable presets")
+
+    temp_dir = (
+        make_temp_dir()
+        if make_temp_dir is not None
+        else Path(tempfile.mkdtemp(prefix="matchpatch_normalization_", dir=PROJECT_DIR))
+    )
+    success = False
+
+    try:
+        csv_path = temp_dir / "lufs_analysis.csv"
+        analysis_request = (
+            request
+            if not request.record_device_output or request.recorded_output_dir is not None
+            else dataclass_replace(request, recorded_output_dir=temp_dir / "recordings")
+        )
+        if snapshot_plan != analysis_request.snapshot_plan:
+            analysis_request = dataclass_replace(analysis_request, snapshot_plan=snapshot_plan)
+        _emit(
+            on_progress,
+            ProgressEvent(
+                "phase",
+                phase="measuring",
+                message="Starting measurement worker...",
+                preset_total=len(preset_ids),
+                snapshot_total=request.policy.snapshot_count,
+            ),
+        )
+        run_analysis(analysis_request, preset_ids, csv_path, on_progress)
+
+        measured_rows = _count_csv_rows(csv_path)
+
+        if measured_rows != len(preset_ids):
+            raise RuntimeError(
+                f"Windows analysis wrote {measured_rows} rows for {len(preset_ids)} presets"
+            )
+
+        if output_path is not None:
+            _emit(
+                on_progress,
+                ProgressEvent("phase", phase="applying", message="Applying adjustments"),
+            )
+            handler.apply_analysis_csv(
+                input_path,
+                output_path,
+                csv_path,
+                request.ignore_bad_lufs,
+                request.target_lufs,
+                request.policy,
+                request.custom_adjustments_path,
+            )
+        elif request.defer_export:
+            preview_path = temp_dir / f"{input_path.stem}_preview{input_path.suffix}"
+            _emit(
+                on_progress,
+                ProgressEvent("phase", phase="applying", message="Calculating adjustments"),
+            )
+            try:
+                handler.apply_analysis_csv(
+                    input_path,
+                    preview_path,
+                    csv_path,
+                    request.ignore_bad_lufs,
+                    request.target_lufs,
+                    request.policy,
+                    request.custom_adjustments_path,
+                )
+            finally:
+                preview_path.unlink(missing_ok=True)
+        success = True
+    finally:
+        if not request.keep_temp and success and not request.defer_export:
+            shutil.rmtree(temp_dir, ignore_errors=True)
+        elif not request.defer_export:
+            _emit(
+                on_progress,
+                ProgressEvent(
+                    "temp_retained",
+                    message=f"Kept temporary CSV: {csv_path}",
+                    path=str(csv_path),
+                ),
+            )
+
+    _emit(
+        on_progress,
+        ProgressEvent(
+            "phase",
+            phase="completed",
+            message=(
+                "Measurement completed; ready to export"
+                if request.defer_export
+                else "Gain-adjusted patch file written"
+            ),
+        ),
+    )
+
+    if request.automation and output_path is not None:
+        _emit(on_progress, ProgressEvent("phase", phase="waiting_for_adjusted_import"))
+        _confirm(
+            confirm_import,
+            ImportRequest("adjusted", profile.display_name, output_path),
+        )
+
+    return NormalizationResult(
+        output_path,
+        temp_dir if request.keep_temp or not success or request.defer_export else None,
+        csv_path if request.keep_temp or not success or request.defer_export else None,
+    )
+
+
+def export_adjusted_file(
+    request: NormalizationRequest,
+    csv_path: Path,
+    output_path: Path,
+    *,
+    adjustments: PatchFileAdjustments | None = None,
+    on_progress: ProgressCallback | None = None,
+    get_profile: ProfileProvider = get_device_profile,
+) -> None:
+    profile = get_profile(request.device)
+    handler = profile.create_patch_file_handler(PROJECT_DIR)
+    log_setter = getattr(handler, "set_log_callback", None)
+    if log_setter is not None:
+        log_setter(lambda message: _emit(on_progress, ProgressEvent("log", message=message)))
+    input_path = request.input_path.resolve()
+    output_path = output_path.resolve()
+    handler.validate_input(input_path)
+    handler.validate_output(input_path, output_path)
+    _validate_custom_adjustments(request)
+    handler.apply_analysis_csv(
+        input_path,
+        output_path,
+        csv_path,
+        request.ignore_bad_lufs,
+        request.target_lufs,
+        request.policy,
+        request.custom_adjustments_path,
+        adjustments,
+    )
+
+
+def _validate_custom_adjustments(request: NormalizationRequest) -> None:
+    if request.custom_adjustments_path is None:
+        return
+    if not request.custom_adjustments_path.is_file():
+        raise ValueError(
+            f"Custom adjustments CSV does not exist: {request.custom_adjustments_path}"
+        )
+    load_custom_adjustments_file(request.custom_adjustments_path, request.policy.snapshot_count)
+
+
+def _intersect_snapshot_plans(
+    first: tuple[tuple[str, tuple[int, ...]], ...],
+    second: tuple[tuple[str, tuple[int, ...]], ...],
+) -> tuple[tuple[str, tuple[int, ...]], ...]:
+    if not first:
+        return second
+    first_by_patch = {patch.upper(): tuple(snapshots) for patch, snapshots in first}
+    result = []
+    for patch, snapshots in second:
+        first_snapshots = first_by_patch.get(patch.upper(), ())
+        selected = tuple(snapshot for snapshot in snapshots if snapshot in first_snapshots)
+        if selected:
+            result.append((patch, selected))
+    return tuple(result)
+
+
+def _emit(callback: ProgressCallback | None, event: ProgressEvent) -> None:
+    if callback is not None:
+        callback(event)
+
+
+def _confirm(callback: ConfirmationCallback | None, request: ImportRequest) -> None:
+    if callback is not None and not callback(request):
+        raise RuntimeError("Normalization cancelled by user")
+
+
+def _count_csv_rows(csv_path: Path) -> int:
+    with csv_path.open("r", encoding="utf-8-sig", newline="") as csv_file:
+        return sum(1 for _ in csv.DictReader(csv_file))

matchpatch-0.4.0.dist-info/METADATA

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: matchpatch
+Version: 0.4.0
+Summary: Audio processor preset gain normalization and measurement tools
+Project-URL: Homepage, https://github.com/noseglasses/MatchPatch
+Project-URL: Issues, https://github.com/noseglasses/MatchPatch/issues
+Project-URL: Repository, https://github.com/noseglasses/MatchPatch.git
+License-File: LICENSE
+Requires-Python: <3.15,>=3.12
+Provides-Extra: gui
+Requires-Dist: pyside6>=6.8; extra == 'gui'
+Description-Content-Type: text/markdown
+
+# MatchPatch
+
+<p align="center">
+  <img src="docs/assets/matchmatch-logo.png" alt="MatchPatch: Normalize presets. Match volume." width="260">
+</p>
+
+[![Quality](https://github.com/noseglasses/MatchPatch/actions/workflows/quality.yml/badge.svg)](https://github.com/noseglasses/MatchPatch/actions/workflows/quality.yml)
+[![Release](https://github.com/noseglasses/MatchPatch/actions/workflows/release.yml/badge.svg)](https://github.com/noseglasses/MatchPatch/actions/workflows/release.yml)
+[![PyPI](https://img.shields.io/pypi/v/matchpatch.svg)](https://pypi.org/project/matchpatch/)
+[![Python](https://img.shields.io/pypi/pyversions/matchpatch.svg)](https://pypi.org/project/matchpatch/)
+
+<p align="center">
+  <strong><a href="https://youtu.be/Dw1Kez0AnCk">Watch the demo video</a></strong>
+  ·
+  <strong><a href="https://noseglasses.github.io/MatchPatch/">Read the documentation</a></strong>
+  ·
+  <strong><a href="https://github.com/noseglasses/MatchPatch/releases/latest">Download MatchPatch</a></strong>
+</p>
+
+![MatchPatch GUI showing a loaded Helix setlist](docs/assets/screenshots/normalization-ongoing.png)
+
+**No more unexpected volume jumps when switching sounds.**
+
+MatchPatch automatically equalizes the loudness of presets and snapshots in
+guitar processors such as the Line 6 Helix.
+
+## Why MatchPatch?
+
+You create a great clean sound. You create a great lead sound. Then you switch
+between them and one is much louder than the other.
+
+MatchPatch measures your presets and calculates the gain adjustments needed to
+make them consistent, so your setlist feels balanced before rehearsal or stage
+use.
+
+## Features
+
+- Measure preset loudness automatically.
+- Analyze snapshots.
+- Calculate required gain corrections.
+- Modify Helix setlists and presets.
+- Test the workflow without hardware.
+- Configure normal runs from the GUI.
+- Use CLI and worker commands for advanced scripting.
+- Open source.
+
+## Current Support
+
+Current normal workflows support:
+
+- Line 6 Helix
+- `.hls` Helix setlists
+- `.hlx` Helix presets
+- GUI-first workflows
+
+Loopback and simulated modes are available for no-hardware tests. Hardware mode
+is for real Helix measurement.
+
+## Documentation
+
+- Online manual: [noseglasses.github.io/MatchPatch](https://noseglasses.github.io/MatchPatch/)
+- Start here: [docs/index.md](docs/index.md)
+- 10-minute guide: [docs/quick-start.md](docs/quick-start.md)
+- Main manual: [docs/musician-guide.md](docs/musician-guide.md)
+- Test without hardware: [docs/workflows/test-without-hardware.md](docs/workflows/test-without-hardware.md)
+- Hardware measurement: [docs/workflows/hardware-measurement.md](docs/workflows/hardware-measurement.md)
+- Reference DI: [docs/concepts/reference-di.md](docs/concepts/reference-di.md)
+- Troubleshooting: [docs/troubleshooting.md](docs/troubleshooting.md)
+- FAQ: [docs/faq.md](docs/faq.md)
+- Glossary: [docs/glossary.md](docs/glossary.md)
+
+## Safety Notes
+
+> Warning:
+> Keep backups of your original Helix files.
+
+> Warning:
+> Measurement files are for measuring, not for live playing.
+
+## Install And Launch
+
+On Windows, download the latest installer from
+[GitHub Releases](https://github.com/noseglasses/MatchPatch/releases/latest),
+run `MatchPatch-Setup-<version>.exe`, then launch MatchPatch from the Start
+Menu. The installed app bundles offline Help, available from the GUI.
+
+For source checkouts, use the verified local setup commands below and see
+[Developer Notes](docs/developer-notes.md) and
+[developer commands](docs/dev/commands.md) for fuller setup details.
+
+Install the optional GUI support and launch MatchPatch:
+
+```bash
+# Linux or WSL
+scripts/sync-wsl.sh --extra gui
+matchpatch-gui
+```
+
+```powershell
+# Windows PowerShell
+cd C:\src\MatchPatch-windows
+.\scripts\sync-windows.cmd --extra gui
+.\.venv-windows\Scripts\matchpatch-gui.exe
+```
+
+Hardware measurement from WSL needs a synced native Windows runtime. See
+[developer commands](docs/dev/commands.md) before using real Helix hardware from
+WSL.
+
+## Advanced And Developer Information
+
+Technical details live in the developer docs:
+
+- [Developer Notes](docs/developer-notes.md)
+- [Architecture](docs/dev/architecture.md)
+- [Commands](docs/dev/commands.md)
+- [File Formats](docs/dev/file-formats.md)
+
+## License
+
+MatchPatch is open source software released under the [MIT License](LICENSE).

matchpatch-0.4.0.dist-info/RECORD

@@ -0,0 +1,29 @@
+matchpatch/__init__.py,sha256=F9nWOCr_UM22K_V3SBR-iOBKKFs1K1eD5sGbxY38heI,610
+matchpatch/analysis.py,sha256=5965dl0UKoZXCfp1o-LQ_EHIglUynZGe0Sfqx9BYrzY,2776
+matchpatch/app.py,sha256=_hqmVrXQ5-CnG3NPQCib8AkMfZJlHJWurMarWnl9Fzw,1950
+matchpatch/audio.py,sha256=anP23VmmlP5V6AJzSVCbGHdD48Evtmf0ZgYFC-Pq_yA,4885
+matchpatch/cli.py,sha256=UIfgN581QHLoV4pIlIa2aP5Ihzp2Vg0LpmD5qwGY4S4,2043
+matchpatch/config.py,sha256=YjflYuoUfTXD0EpR6tYzHkD61JWQk6FPdA0WWdStMJ4,5992
+matchpatch/custom_adjustments.py,sha256=9vrPBCK8zbAP9vSAudhYCQwkttIg9urUtkA_OasqMDc,2312
+matchpatch/measure.py,sha256=c3gJFFBoiMqR6eO-BktYMnEUCAgcqkgX1p6qhMZNBSk,44255
+matchpatch/measurement_optimizer.py,sha256=3CgDKCWEKRbnsP6lsdxlKaRTPV0bUDh29-w3mIBYSvo,22785
+matchpatch/normalize.py,sha256=ZxoEYGHwlG4g4pVyEJ5HqeonTj397huRUkyMqC1x4wI,30139
+matchpatch/progress.py,sha256=uMxTHpE5BBKP_jFdJU3-dsnDxnfMDu21GV0NKlVtsTE,1124
+matchpatch/workflow.py,sha256=u1uQqTNtp68pvimbZWMqIe3PQPPsVvyqjO9UTMfh8_w,12928
+matchpatch/devices/__init__.py,sha256=nC4WfuzMOQmFPrSgrsIF-hIRBTVDpHl1a5nzFld1-gw,196
+matchpatch/devices/base.py,sha256=FPY-k4l3lW968ULBArlUgGqXxiSyqzqTAemALO03O_w,6677
+matchpatch/devices/helix.py,sha256=ZcXtfU0j2inSGVIBlt7LN6wFxrO7fEmAebLFz35buKk,15763
+matchpatch/devices/registry.py,sha256=SgfqsVHmvT-mItbhiBP8I5NHwNIS05fVd5rBih3DDUc,642
+matchpatch/gui/__init__.py,sha256=PD5RmVUlqzMUz3rQRzvC8YN58R9Yb0805O08wp9OlnM,48
+matchpatch/gui/app.py,sha256=iB1WMgU82yJtXy6eeX_3hH170o0DYEHQgl8iZpW-LH4,6485
+matchpatch/gui/device_panels.py,sha256=bxptD85eDKxVwKnNC6y0izxn5IpQTIrV7Jt60rCucS8,5328
+matchpatch/gui/dialogs.py,sha256=ab7PDn__gzRCZOw-VWkGsCX048rIYD0a6OAaCf7RcY4,5810
+matchpatch/gui/help.py,sha256=g2km4N0--0D_wXwLqtcgGevXs2dIUmnslClpt6qe11E,7464
+matchpatch/gui/main_window.py,sha256=25yBPKgjcP8NPWczY3CaGL9S4I41dvoODRMU8hotKhs,322861
+matchpatch/gui/snapshot_header.py,sha256=ZuZdXkZHZTOlI6kuax7lj_SvAIcNnCsF2bk8N8pZLO8,1927
+matchpatch/gui/worker.py,sha256=CzMBTvMFgQ4wSTtsO8nTb0WkTzLmboUezuD2wVA62P0,4239
+matchpatch-0.4.0.dist-info/METADATA,sha256=tczsa4V3FLx2h9-RHBKyEb2LSQ7GQ47BX6BolboboOY,4799
+matchpatch-0.4.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+matchpatch-0.4.0.dist-info/entry_points.txt,sha256=kjAMZz7z0FH-8lNWGE6ECXq664vPId54K6bRvc6eSH8,92
+matchpatch-0.4.0.dist-info/licenses/LICENSE,sha256=8pi7wtiIu5UFxxFQwLfTi7DudedhoPhOldqL5Z00LTo,1080
+matchpatch-0.4.0.dist-info/RECORD,,

matchpatch-0.4.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

matchpatch-0.4.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+matchpatch = matchpatch.cli:main
+matchpatch-gui = matchpatch.gui.app:main

matchpatch-0.4.0.dist-info/licenses/LICENSE

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