capkit 0.1.0__py3-none-any.whl

capkit/__init__.py

@@ -0,0 +1,13 @@
+"""Read CAN log files into a common stream of frame objects."""
+from __future__ import annotations
+
+from capkit.io import available_formats, probe, read
+from capkit.model import Frame, LogMeta
+from capkit.readers import register_reader
+
+__all__ = [
+    # model
+    "Frame", "LogMeta",
+    # io
+    "read", "probe", "available_formats", "register_reader",
+]

capkit/integration.py

@@ -0,0 +1,22 @@
+"""Adapters exposed to dbckit through package entry points."""
+from __future__ import annotations
+
+from collections.abc import Iterator
+from pathlib import Path
+
+from capkit.model import Frame
+from capkit.readers import create_reader
+
+
+class DispatchReader:
+    """Sniff and delegate generic file extensions such as ``.txt``."""
+
+    def __init__(self, *, strict: bool = False, **reader_options: object) -> None:
+        self.strict = strict
+        self.reader_options = reader_options
+
+    def read(self, path: Path) -> Iterator[Frame]:
+        """Lazily sniff *path* and yield frames from the matching reader."""
+        options = {"strict": self.strict, **self.reader_options}
+        reader = create_reader(path, options=options, sniff_only=True)
+        yield from reader.read(path)

capkit/io.py

@@ -0,0 +1,38 @@
+"""Public file-reading and format-discovery operations."""
+from __future__ import annotations
+
+from collections.abc import Iterator
+from pathlib import Path
+
+from capkit.model import Frame, LogMeta
+from capkit.readers import create_reader, registered_formats
+
+
+def read(
+    path: str | Path,
+    *,
+    format: str | None = None,
+    strict: bool = False,
+    **reader_options: object,
+) -> Iterator[Frame]:
+    """Lazily read frames from *path* using an explicit or detected format."""
+    source = Path(path)
+
+    def frames() -> Iterator[Frame]:
+        options = {"strict": strict, **reader_options}
+        reader = create_reader(source, format=format, options=options)
+        yield from reader.read(source)
+
+    return frames()
+
+
+def probe(path: str | Path, *, format: str | None = None) -> LogMeta:
+    """Return cheap, header-derived metadata for *path*."""
+    source = Path(path)
+    reader = create_reader(source, format=format)
+    return reader.probe(source)
+
+
+def available_formats() -> list[str]:
+    """Return the sorted names of registered log formats."""
+    return registered_formats()

capkit/model/__init__.py

@@ -0,0 +1,6 @@
+"""Core immutable log models."""
+from __future__ import annotations
+
+from capkit.model.frame import Frame, LogMeta
+
+__all__ = ["Frame", "LogMeta"]

capkit/model/frame.py

@@ -0,0 +1,30 @@
+"""Common frame and log-metadata models."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+
+
+@dataclass(frozen=True, slots=True)
+class Frame:
+    """A single CAN frame read from a log file."""
+
+    timestamp: float
+    arbitration_id: int
+    data: bytes
+    channel: int | None = None
+    is_extended_frame: bool = False
+    is_fd: bool = False
+    is_remote_frame: bool = False
+    is_error_frame: bool = False
+    is_rx: bool | None = None
+    dlc: int | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class LogMeta:
+    """Cheap, header-derived metadata about a log file."""
+
+    format: str
+    start_time: datetime | None = None
+    extra: dict[str, str] = field(default_factory=dict)

capkit/operations/__init__.py

@@ -0,0 +1,2 @@
+"""Reserved namespace for future stream operations."""
+from __future__ import annotations

capkit/py.typed

@@ -0,0 +1 @@
+

capkit/readers/__init__.py

@@ -0,0 +1,104 @@
+"""Reader registry and format-resolution logic."""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import cast
+
+from capkit.readers.base import Reader, read_sample
+from capkit.readers.kvaser_txt import KvaserTxtReader
+
+_READERS: dict[str, type[Reader]] = {
+    KvaserTxtReader.name: cast(type[Reader], KvaserTxtReader),
+}
+
+
+def register_reader(reader_type: type[Reader]) -> None:
+    """Register a zero-argument reader class for process-wide format resolution."""
+    if not isinstance(reader_type, type):
+        raise TypeError("register_reader() requires a reader class, not an instance.")
+
+    name = getattr(reader_type, "name", None)
+    if not isinstance(name, str) or not name.strip():
+        raise TypeError("Reader type must define a non-empty string 'name'.")
+
+    normalized = name.strip().lower()
+    if normalized in _READERS:
+        raise ValueError(f"Log format '{normalized}' is already registered.")
+
+    extensions = getattr(reader_type, "extensions", None)
+    if (
+        not isinstance(extensions, tuple)
+        or not extensions
+        or any(not isinstance(extension, str) or not extension.startswith(".") for extension in extensions)
+    ):
+        raise TypeError(
+            f"Reader type '{normalized}' must define a non-empty tuple of dot-prefixed extensions."
+        )
+
+    try:
+        reader = reader_type()
+    except Exception as error:
+        raise TypeError(f"Reader type '{normalized}' must be zero-argument constructible.") from error
+
+    if any(not callable(getattr(reader, method, None)) for method in ("sniff", "probe", "read")):
+        raise TypeError(f"Reader type '{normalized}' must define callable sniff(), probe(), and read() methods.")
+
+    _READERS[normalized] = reader_type
+
+
+def registered_formats() -> list[str]:
+    """Return sorted registered reader names."""
+    return sorted(_READERS)
+
+
+def _available_label() -> str:
+    return ", ".join(registered_formats())
+
+
+def _reader_type_for(
+    path: Path,
+    *,
+    format: str | None = None,
+    sniff_only: bool = False,
+) -> type[Reader]:
+    if not _READERS:
+        raise ValueError("No log formats are registered.")
+
+    if format is not None:
+        normalized = format.strip().lower()
+        reader_type = _READERS.get(normalized)
+        if reader_type is None:
+            raise ValueError(f"Unknown log format '{format}'. Available formats: {_available_label()}.")
+        return reader_type
+
+    if not sniff_only:
+        extension = path.suffix.lower()
+        candidates = [
+            reader_type
+            for reader_type in _READERS.values()
+            if extension and extension in (claimed.lower() for claimed in reader_type.extensions)
+        ]
+        if len(candidates) == 1:
+            return candidates[0]
+
+    sample = read_sample(path)
+    matches = [reader_type for reader_type in _READERS.values() if reader_type().sniff(sample)]
+    if len(matches) == 1:
+        return matches[0]
+
+    raise ValueError(f"Unknown log format for '{path.name}'. Available formats: {_available_label()}.")
+
+
+def create_reader(
+    path: Path,
+    *,
+    format: str | None = None,
+    options: dict[str, object] | None = None,
+    sniff_only: bool = False,
+) -> Reader:
+    """Resolve and construct a reader for *path*."""
+    reader_type = _reader_type_for(path, format=format, sniff_only=sniff_only)
+    return cast(Reader, reader_type(**(options or {})))
+
+
+__all__ = ["KvaserTxtReader", "Reader", "register_reader"]

capkit/readers/base.py

@@ -0,0 +1,35 @@
+"""Shared reader protocol and bounded file-sampling helper."""
+from __future__ import annotations
+
+from collections.abc import Iterator
+from pathlib import Path
+from typing import Protocol
+
+from capkit.model import Frame, LogMeta
+
+SNIFF_SIZE = 4096
+
+
+class Reader(Protocol):
+    """A stateless log-format reader."""
+
+    name: str
+    extensions: tuple[str, ...]
+
+    def sniff(self, sample: str) -> bool:
+        """Return whether *sample* looks like this reader's format."""
+        ...
+
+    def probe(self, path: Path) -> LogMeta:
+        """Return cheap metadata from *path*."""
+        ...
+
+    def read(self, path: Path) -> Iterator[Frame]:
+        """Lazily yield frames from *path*."""
+        ...
+
+
+def read_sample(path: Path) -> str:
+    """Read and Latin-1 decode at most the first 4 KiB of *path*."""
+    with path.open("rb") as stream:
+        return stream.read(SNIFF_SIZE).decode("latin-1")

capkit/readers/kvaser_txt.py

@@ -0,0 +1,92 @@
+"""Reader for Kvaser CanKing text exports."""
+from __future__ import annotations
+
+import re
+from collections.abc import Iterator
+from pathlib import Path
+from re import Match
+
+from capkit.model import Frame, LogMeta
+from capkit.readers.base import read_sample
+
+
+class KvaserTxtReader:
+    """Read the whitespace-delimited Kvaser CanKing TXT dialect."""
+
+    name = "kvaser-txt"
+    extensions = (".txt",)
+
+    _FRAME_RE = re.compile(
+        r"^\s*"
+        r"(?P<channel>\d+)"
+        r"\s+(?P<identifier>[0-9A-Fa-f]+)"
+        r"(?:\s+(?P<flag>[xX]))?"
+        r"\s+(?P<dlc>\d+)"
+        r"(?P<data>(?:\s+[0-9A-Fa-f]{2})*)"
+        r"\s+(?P<timestamp>\d+(?:\.\d+)?)"
+        r"\s+(?P<direction>[RrTt])"
+        r"\s*$"
+    )
+
+    def __init__(self, *, strict: bool = False) -> None:
+        self.strict = strict
+
+    @staticmethod
+    def _is_header(line: str) -> bool:
+        normalized = " ".join(line.lower().split())
+        return normalized.startswith("chn identifier flg dlc") and "time" in normalized and "dir" in normalized
+
+    @staticmethod
+    def _data_tokens(match: Match[str]) -> list[str]:
+        return match.group("data").split()
+
+    @classmethod
+    def _is_complete_frame(cls, match: Match[str]) -> bool:
+        return len(cls._data_tokens(match)) == int(match.group("dlc"))
+
+    def sniff(self, sample: str) -> bool:
+        """Recognize the Kvaser table header or a complete frame line."""
+        for line in sample.splitlines():
+            if self._is_header(line):
+                return True
+            match = self._FRAME_RE.fullmatch(line)
+            if match is not None and self._is_complete_frame(match):
+                return True
+        return False
+
+    def probe(self, path: Path) -> LogMeta:
+        """Return Kvaser metadata without scanning the frame body."""
+        if not self.sniff(read_sample(path)):
+            raise ValueError(f"File '{path.name}' is not a Kvaser TXT log.")
+        return LogMeta(format=self.name)
+
+    def read(self, path: Path) -> Iterator[Frame]:
+        """Lazily parse Kvaser frame records from *path*."""
+        with path.open(encoding="latin-1") as stream:
+            for line_number, raw_line in enumerate(stream, start=1):
+                line = raw_line.rstrip("\r\n")
+                if not line.strip():
+                    continue
+
+                match = self._FRAME_RE.fullmatch(line)
+                if match is None:
+                    if self.strict:
+                        raise ValueError(f"Unrecognized Kvaser TXT line {line_number}: {line!r}.")
+                    continue
+
+                data_tokens = self._data_tokens(match)
+                dlc = int(match.group("dlc"))
+                if len(data_tokens) != dlc:
+                    raise ValueError(
+                        f"Invalid Kvaser TXT frame at line {line_number}: "
+                        f"DLC {dlc} declares {dlc} data bytes, got {len(data_tokens)}."
+                    )
+
+                yield Frame(
+                    timestamp=float(match.group("timestamp")),
+                    arbitration_id=int(match.group("identifier"), 16),
+                    data=bytes.fromhex(" ".join(data_tokens)),
+                    channel=int(match.group("channel")),
+                    is_extended_frame=match.group("flag") is not None,
+                    is_rx=match.group("direction").upper() == "R",
+                )

capkit/writers/__init__.py

@@ -0,0 +1,2 @@
+"""Reserved namespace for future log writers."""
+from __future__ import annotations

capkit-0.1.0.dist-info/METADATA

@@ -0,0 +1,240 @@
+Metadata-Version: 2.4
+Name: capkit
+Version: 0.1.0
+Summary: Read CAN bus capture logs in different formats into one common frame stream
+Project-URL: Homepage, https://canforge.io/capkit
+Project-URL: Repository, https://github.com/canforge/capkit
+Project-URL: Changelog, https://github.com/canforge/capkit/blob/main/CHANGELOG.md
+Author-email: André Delgado <andre@adelgado.io>
+License: MIT License
+        
+        Copyright (c) 2026 André Delgado
+        
+        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
+Keywords: CAN,automotive,canbus,kvaser,log
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+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
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.11
+Provides-Extra: dev
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: dbckit>=1.0; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# capkit
+
+[![PyPI](https://img.shields.io/pypi/v/capkit)](https://pypi.org/project/capkit/)
+[![CI](https://github.com/canforge/capkit/actions/workflows/ci.yml/badge.svg)](https://github.com/canforge/capkit/actions/workflows/ci.yml)
+[![Python versions](https://img.shields.io/pypi/pyversions/capkit)](https://pypi.org/project/capkit/)
+[![License: MIT](https://img.shields.io/pypi/l/capkit)](LICENSE)
+
+`capkit` is a Python library that reads **CAN bus capture logs into one common
+frame stream**. Every supported format parses into the same frozen `Frame`
+dataclass, so code that consumes frames never depends on which tool captured
+the log.
+
+Use it to:
+
+- read captures from different tools as one lazy stream of typed `Frame` objects
+- probe a file for header metadata without scanning the frame body
+- detect the log format from the file extension or the file content
+- skip real-world log noise by default, or reject it with `strict=True`
+- feed frames into [dbckit](https://github.com/canforge/dbckit) for DBC signal decoding
+
+| Format | Reader name | Extensions | Status | Dependency |
+|---|---|---|---|---|
+| Kvaser CanKing TXT | `kvaser-txt` | `.txt` | Supported | none |
+| candump text | `candump` | `.log` | Planned | none |
+| Vector ASC | `vector-asc` | `.asc` | Planned | none |
+| PCAN TRC | `pcan-trc` | `.trc` | Planned | none |
+| Generic CSV | `csv-table` | `.csv` | Planned | none |
+| Vector BLF | `vector-blf` | `.blf` | Planned adapter | `python-can` |
+| ASAM MF4 | `asam-mf4` | `.mf4` | Planned adapter | `asammdf` |
+
+See [format support](docs/format-support.md) for the exact dialect each reader
+accepts, and the [roadmap](ROADMAP.md) for sequencing.
+
+## Install
+
+```bash
+pip install capkit
+```
+
+Requires Python `>=3.11`. capkit has no runtime dependencies.
+
+## Design
+
+- `Frame` and `LogMeta` are frozen, slotted dataclasses.
+- `read()` is lazy and keeps constant parser state, so file size does not matter.
+- Timestamps are returned exactly as recorded in the source, never rebased or
+  converted to absolute time.
+- A format is added only when a real captured fixture pins its dialect under
+  `tests/fixtures/`; unsupported dialects fail clearly instead of parsing
+  approximately.
+
+## Quick Start
+
+```python
+import capkit
+
+# stream frames
+for frame in capkit.read("trace.txt"):
+    print(frame.timestamp, hex(frame.arbitration_id), frame.data.hex())
+
+# header metadata only
+meta = capkit.probe("trace.txt")
+print(meta.format, meta.start_time)
+
+# registered reader names
+print(capkit.available_formats())   # ['kvaser-txt']
+```
+
+The public API is six names: `read`, `probe`, `available_formats`,
+`register_reader`, `Frame`, and `LogMeta`.
+
+## Features
+
+### Format detection
+
+An explicit `format=` names a reader and takes precedence over the file
+extension:
+
+```python
+frames = capkit.read("capture.bin", format="kvaser-txt")
+```
+
+Without `format=`, capkit matches the extension against registered readers and
+sniffs the first 4 KiB when the extension is unknown or ambiguous.
+
+### Add your own reader
+
+Register a zero-argument reader class to make it available to `read()`,
+`probe()`, and format detection:
+
+```python
+from collections.abc import Iterator
+from pathlib import Path
+
+import capkit
+
+
+class MyReader:
+    name: str = "my-format"
+    extensions: tuple[str, ...] = (".mylog",)
+
+    def __init__(self, *, strict: bool = False) -> None:
+        self.strict = strict
+
+    def sniff(self, sample: str) -> bool:
+        return sample.startswith("MYLOG")
+
+    def probe(self, path: Path) -> capkit.LogMeta:
+        return capkit.LogMeta(format=self.name)
+
+    def read(self, path: Path) -> Iterator[capkit.Frame]:
+        # Parse path lazily and yield capkit.Frame objects here.
+        yield from ()
+
+
+capkit.register_reader(MyReader)
+```
+
+Registration is process-global and is normally performed at import time.
+dbckit's `.txt` entry point sniffs among all registered readers, so a reader
+whose `sniff()` uniquely matches the content of a `.txt` log is used there
+too, regardless of the extensions it claims.
+
+### Dirty logs and strict mode
+
+Readers skip headers, trailers, comments, blank lines, and unrelated noise by
+default. Pass `strict=True` to raise a line-numbered `ValueError` on the first
+unrecognized nonblank line instead:
+
+```python
+frames = capkit.read("trace.txt", strict=True)
+```
+
+A frame record whose DLC disagrees with its data bytes raises in both modes;
+corrupt frames are never silently dropped.
+
+## Use with dbckit
+
+[dbckit](https://github.com/canforge/dbckit) decodes CAN frames against a DBC
+database. capkit and dbckit are separate packages — neither depends on or
+imports the other — with adjacent jobs: capkit turns bytes on disk into frames,
+dbckit turns frames plus a DBC into signals.
+
+```python
+import capkit
+import dbckit
+
+db = dbckit.load("truck.dbc")
+for decoded in dbckit.decode_frames(db, capkit.read("trace.txt")):
+    print(decoded.timestamp, decoded.signals)
+```
+
+capkit also registers its readers in dbckit's `dbckit.readers` entry-point
+group. With both packages installed, `dbckit.decode_log()` reads `.txt` logs
+through capkit directly:
+
+```python
+for decoded in dbckit.decode_log(db, "trace.txt"):
+    print(decoded.signals)
+```
+
+## Scope and Caveats
+
+- Kvaser dialects with absolute start-time headers are not supported;
+  `probe()` returns `start_time=None` for `kvaser-txt`.
+- capkit reads frames only: no DBC or signal awareness (that is dbckit's job),
+  no hardware I/O, no log writing, no dataframe export, no CLI.
+
+## Documentation
+
+- [Format support](docs/format-support.md) — supported formats and the exact
+  dialect each reader accepts
+- [API reference](docs/api-reference.md) — the public API contract
+- [Recipes](docs/recipes.md) — counting IDs, filtering, time windows, CSV
+  export, and dataframes in a few lines of standard library
+
+## Development
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -e ".[dev]"
+pytest
+```
+
+The `dev` extra includes dbckit so the entry-point integration tests run; the
+core and contract suites pass without it.
+
+## License
+
+MIT

capkit-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+capkit/__init__.py,sha256=l6KOaVUfBHbeibn7CX1xACeT-uxq9BEfSzPIQQR-LGU,357
+capkit/integration.py,sha256=Yc7BNz-eByJh9wMQ08SkgAgwzhux5ZLCyDqxo3Zmno8,789
+capkit/io.py,sha256=2gLk-zCjlW9zpmZLL1X4y4jttJh0npkjajOhROoavS4,1107
+capkit/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+capkit/model/__init__.py,sha256=Rg3bkQjSPsGIsXoZAfMiSeeeiPO6S6jvMoFr_InTxQw,147
+capkit/model/frame.py,sha256=XQyqVHuSAh_fI3zjLZJEkqaFauj8cb8tBvdpbwYdzSk,754
+capkit/operations/__init__.py,sha256=ksgo7TaQtvU9fvGGrrfAyYS4o-axtDbkPGGZ9I_dwfs,90
+capkit/readers/__init__.py,sha256=3BQ9ZT8-xwRNNO3fNZ-GYijlnjg1q69Qbp9Ma7bC4Ro,3475
+capkit/readers/base.py,sha256=YZD1kKgRP6l06u2zhAvYSaRD-Y3E3emjyTv6nBBi74Q,906
+capkit/readers/kvaser_txt.py,sha256=PmOsHW4mikQ6T9ZOTS--nHut7VxEpszmRpg2u2w84KA,3386
+capkit/writers/__init__.py,sha256=9XwmWR0Y4bp3KnIh0MMjQk1cHZjX_bX6-su3Ho8hWzw,84
+capkit-0.1.0.dist-info/METADATA,sha256=6UUFM4aAKMm7XLO_svalqC44L3s5wmEF37XNQobFtRA,8470
+capkit-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+capkit-0.1.0.dist-info/entry_points.txt,sha256=5NWQwqFV5V6S-qnkTgr2o8lFoLu87Z9HN36gevqDNmQ,57
+capkit-0.1.0.dist-info/licenses/LICENSE,sha256=VArw2mCCiRiU3jUc906yLPYKJCOtrNFyAINYPHzO-1g,1071
+capkit-0.1.0.dist-info/RECORD,,

capkit-0.1.0.dist-info/WHEEL

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

capkit-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[dbckit.readers]
+txt = capkit.integration:DispatchReader

capkit-0.1.0.dist-info/licenses/LICENSE

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