blockpath 0.1.0__py3-none-any.whl

blockpath/symbols.py

@@ -0,0 +1,284 @@
+"""Layer 2: what each name means, at module scope and inside every function.
+
+Two questions the resolver cannot answer without this layer:
+
+* **At module scope**, is ``sleep`` a function defined here, a name imported from ``time``, or
+  a plain assignment? Built from the AST: ``top_level`` maps each top-level name to a
+  :class:`Definition` or an :class:`ImportBinding`, and a name bound two incompatible ways is
+  marked ambiguous so the resolver refuses to guess.
+
+* **Inside a function**, is ``sleep`` a *local* thing (a parameter, an assignment) that shadows
+  the module ``sleep``, or a *local import* (``def h(): import time``) that should resolve, or a
+  reference to the outer name? This is where reimplementing Python's scoping rules would be a
+  mistake, so we ask the standard library: ``symtable`` classifies every name in a scope as
+  local / imported / global / free / parameter, and gets the corners right -- ``global x`` inside
+  a function refers to the module ``x``, an inlined comprehension target is local, a nested
+  ``def`` name is local. We keep only the classification and read the actual import *targets*
+  back from the AST, since ``symtable`` does not carry them.
+
+Scopes are keyed by ``(name, lineno)`` -- unique for real functions and classes; the only
+collisions are several lambdas or genexprs on one physical line, which are marked ambiguous and
+handled conservatively (treat every name as a shadow, i.e. resolve nothing there -- the safe
+direction). A ``def f[T]()`` generic adds a ``type parameter`` wrapper scope in ``symtable``; we
+skip the wrapper and key the real function scope.
+"""
+
+from __future__ import annotations
+
+import ast
+import symtable
+from dataclasses import dataclass
+from typing import Literal
+
+from blockpath.collect import Module
+
+#: How Python names a lambda / generator-expression scope in symtable.
+_LAMBDA = "lambda"
+_GENEXPR = "genexpr"
+
+#: A node that introduces a function scope.
+ScopeNode = ast.FunctionDef | ast.AsyncFunctionDef | ast.Lambda
+#: A ``def``/``async def`` (a lambda has no statement body).
+FuncNode = ast.FunctionDef | ast.AsyncFunctionDef
+
+
+@dataclass(frozen=True, slots=True)
+class Definition:
+    """A function or class defined at module top level."""
+
+    qualname: str
+    kind: Literal["function", "class"]
+
+
+@dataclass(frozen=True, slots=True)
+class ImportBinding:
+    """A top-level name bound by an import, pointing at a dotted target (possibly external)."""
+
+    target: str
+
+
+Symbol = Definition | ImportBinding
+
+
+@dataclass(frozen=True, slots=True)
+class ModuleSymbols:
+    """The top-level name table of one module."""
+
+    module: Module
+    top_level: dict[str, Symbol]
+    ambiguous: frozenset[str]
+    has_star_import: bool
+
+
+@dataclass(frozen=True, slots=True)
+class ScopeInfo:
+    """What is bound locally inside one function scope."""
+
+    #: name -> dotted import target, for imports written in this function's own body
+    local_imports: dict[str, str]
+    #: names bound locally that are not imports: parameters, assignments, nested defs, ...
+    shadows: frozenset[str]
+    #: when True, treat *every* callee name as shadowed and resolve nothing. Used when the scope
+    #: could not be mapped unambiguously, so guessing would risk a fabricated edge.
+    shadow_all: bool = False
+
+
+#: A scope whose symtable mapping was ambiguous or missing: resolve nothing through it (shadow
+#: everything). Conservative -- an undercount, never a false finding.
+_OPAQUE_SCOPE = ScopeInfo(local_imports={}, shadows=frozenset(), shadow_all=True)
+
+
+def _relative_base(module: Module, level: int) -> str | None:
+    """The package a ``from . import x`` at ``level`` dots resolves against, or None if it walks
+    above the top package (which Python rejects as 'beyond top-level package')."""
+    parts = module.qualname.split(".") if module.qualname else []
+    if not module.is_package:
+        parts = parts[:-1]  # a module resolves relatives against its containing package
+    up = level - 1
+    if up >= len(parts):
+        return None  # one more dot than there are package components: beyond the top
+    if up:
+        parts = parts[:-up]
+    return ".".join(parts)
+
+
+def import_bindings(stmt: ast.Import | ast.ImportFrom, module: Module) -> list[tuple[str, str]]:
+    """Names an import binds, each with its dotted target. ``("*", "*")`` signals a star import."""
+    out: list[tuple[str, str]] = []
+    if isinstance(stmt, ast.Import):
+        for alias in stmt.names:
+            if alias.asname:
+                out.append((alias.asname, alias.name))
+            else:
+                top = alias.name.split(".")[0]
+                out.append((top, top))
+        return out
+    if stmt.level:
+        base = _relative_base(module, stmt.level)
+        if base is None:
+            return out
+        prefix = f"{base}.{stmt.module}" if stmt.module else base
+    else:
+        prefix = stmt.module or ""
+    if not prefix:
+        return out
+    for alias in stmt.names:
+        if alias.name == "*":
+            out.append(("*", "*"))
+        else:
+            out.append((alias.asname or alias.name, f"{prefix}.{alias.name}"))
+    return out
+
+
+def _build_top_level(module: Module) -> ModuleSymbols:
+    seen: dict[str, list[Symbol]] = {}
+    last_bind_line: dict[str, int] = {}
+    deleted: set[str] = set()
+    star_lines: list[int] = []
+
+    def bind(name: str, sym: Symbol, line: int) -> None:
+        seen.setdefault(name, []).append(sym)
+        last_bind_line[name] = max(last_bind_line.get(name, 0), line)
+
+    for stmt in module.tree.body:
+        match stmt:
+            case ast.FunctionDef() | ast.AsyncFunctionDef():
+                bind(
+                    stmt.name, Definition(f"{module.qualname}.{stmt.name}", "function"), stmt.lineno
+                )
+            case ast.ClassDef():
+                bind(stmt.name, Definition(f"{module.qualname}.{stmt.name}", "class"), stmt.lineno)
+            case ast.Import() | ast.ImportFrom():
+                for name, target in import_bindings(stmt, module):
+                    if name == "*":
+                        star_lines.append(stmt.lineno)
+                    else:
+                        bind(name, ImportBinding(target), stmt.lineno)
+            case ast.Assign() | ast.AnnAssign() | ast.AugAssign():
+                targets = stmt.targets if isinstance(stmt, ast.Assign) else [stmt.target]
+                for tgt in targets:
+                    if isinstance(tgt, ast.Name):
+                        bind(tgt.id, ImportBinding(""), stmt.lineno)  # opaque module-level rebind
+            case ast.Delete():
+                for tgt in stmt.targets:
+                    if isinstance(tgt, ast.Name):
+                        deleted.add(tgt.id)  # `del name` removes the top-level binding
+            case _:
+                pass
+
+    has_star = bool(star_lines)
+    last_star = max(star_lines) if star_lines else -1
+
+    top_level: dict[str, Symbol] = {}
+    ambiguous: set[str] = set()
+    for name, syms in seen.items():
+        variants = {_symbol_key(s) for s in syms}
+        first = syms[0]
+        idempotent_import = (
+            len(variants) == 1 and isinstance(first, ImportBinding) and bool(first.target)
+        )
+        # A `from x import *` executed after a name is bound can silently overwrite it, and we do
+        # not expand stars (ADR 0006), so such a name is ambiguous, not definite.
+        overridden_by_star = has_star and last_bind_line[name] < last_star
+        if name in deleted:
+            ambiguous.add(name)  # bound then `del`eted: at runtime the name is gone
+        elif (len(syms) > 1 and not idempotent_import) or overridden_by_star:
+            ambiguous.add(name)
+        elif isinstance(first, ImportBinding) and not first.target:
+            ambiguous.add(name)  # a bare module-level assignment: not resolvable, do not follow
+        else:
+            top_level[name] = first
+    return ModuleSymbols(module, top_level, frozenset(ambiguous), has_star)
+
+
+def _symbol_key(sym: Symbol) -> tuple[str, str]:
+    if isinstance(sym, Definition):
+        return ("def", sym.qualname + sym.kind)
+    return ("import", sym.target)
+
+
+class ModuleScopes:
+    """Per-function scope classification for one module, backed by symtable."""
+
+    def __init__(self, module: Module) -> None:
+        self._module = module
+        self._by_key: dict[tuple[str, int], symtable.SymbolTable] = {}
+        self._ambiguous_keys: set[tuple[str, int]] = set()
+        self.desynced = False
+        try:
+            top = symtable.symtable(module.source, module.relpath, "exec")
+        except (SyntaxError, ValueError):
+            self.desynced = True
+            return
+        self._index(top)
+
+    def _index(self, scope: symtable.SymbolTable) -> None:
+        for child in scope.get_children():
+            kind = child.get_type()
+            if kind == "type parameter":
+                self._index(child)  # skip the PEP 695 wrapper, register its inner scope
+                continue
+            if kind in ("function", "class"):
+                key = (child.get_name(), child.get_lineno())
+                if key in self._by_key:
+                    self._ambiguous_keys.add(key)
+                self._by_key[key] = child
+                self._index(child)
+
+    def info(self, node: ScopeNode) -> ScopeInfo:
+        if self.desynced:
+            return _OPAQUE_SCOPE
+        name = _LAMBDA if isinstance(node, ast.Lambda) else node.name
+        key = (name, node.lineno)
+        if key in self._ambiguous_keys or key not in self._by_key:
+            return _OPAQUE_SCOPE
+        scope = self._by_key[key]
+        # A name shadows the module if it is bound locally (but not as an import, which we
+        # resolve) OR is free -- closing over an enclosing function scope. In Python's LEGB, an
+        # enclosing binding beats the module global, so a free variable is not the module name.
+        shadows = frozenset(
+            sym.get_name()
+            for sym in scope.get_symbols()
+            if (sym.is_local() and not sym.is_imported()) or sym.is_free()
+        )
+        return ScopeInfo(local_imports=self._local_imports(node), shadows=shadows)
+
+    def _local_imports(self, node: ScopeNode) -> dict[str, str]:
+        if isinstance(node, ast.Lambda):
+            return {}  # a lambda body is a single expression: no import statements
+        out: dict[str, str] = {}
+        for stmt in _scope_import_stmts(node):
+            for name, target in import_bindings(stmt, self._module):
+                if name != "*":
+                    out[name] = target
+        return out
+
+
+def _scope_import_stmts(fn: FuncNode) -> list[ast.Import | ast.ImportFrom]:
+    """Import statements executed in ``fn``'s scope, descending into ``if``/``try``/``with``/loops
+    but never into a nested function, class, or lambda (whose imports are local to *them*)."""
+    out: list[ast.Import | ast.ImportFrom] = []
+
+    def visit(node: ast.AST) -> None:
+        if isinstance(node, ast.Import | ast.ImportFrom):
+            out.append(node)
+            return
+        if isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef | ast.Lambda):
+            return  # nested scope: pruned
+        for child in ast.iter_child_nodes(node):
+            visit(child)
+
+    for stmt in fn.body:
+        visit(stmt)
+    return out
+
+
+@dataclass(slots=True)
+class Analysis:
+    symbols: ModuleSymbols
+    scopes: ModuleScopes
+
+
+def analyze(module: Module) -> Analysis:
+    """Top-level symbols plus per-function scope classification for one module."""
+    return Analysis(symbols=_build_top_level(module), scopes=ModuleScopes(module))

blockpath-0.1.0.dist-info/METADATA

@@ -0,0 +1,180 @@
+Metadata-Version: 2.4
+Name: blockpath
+Version: 0.1.0
+Summary: Find blocking calls reachable from a coroutine, and print the whole call path across files and modules.
+Project-URL: Repository, https://github.com/iraettae/blockpath
+Project-URL: Issues, https://github.com/iraettae/blockpath/issues
+Author: Damir
+License-Expression: MIT
+License-File: LICENSE
+Keywords: asyncio,blocking,call-graph,event-loop,linter,static-analysis
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: click>=8.1
+Requires-Dist: pathspec>=0.12
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: rich>=13.7
+Description-Content-Type: text/markdown
+
+# blockpath
+
+[![ci](https://github.com/iraettae/blockpath/actions/workflows/ci.yml/badge.svg)](https://github.com/iraettae/blockpath/actions/workflows/ci.yml)
+[![python](https://img.shields.io/badge/python-3.12%2B-blue)](https://www.python.org/downloads/)
+
+Find the synchronous call that stalls your event loop, and print the whole path to it: from the
+`async` handler down through `services/` and `clients/` to the blocking `requests.get`, across as
+many files and modules as it takes.
+
+Existing linters catch a blocking call only when it sits directly in the `async def` body. In
+real code it almost never does -- it is three to five calls deep, in another module, behind a
+couple of helpers nobody thinks about. That is where it hides, and that is what blockpath finds.
+
+## The problem is real, and it was measured before a line of the analyzer was written
+
+A survey of **57 public aiogram/FastAPI repositories**, with the protocol and thresholds
+[registered in advance](benchmark/PREREGISTRATION.md) so the result could not be steered, asked
+one question: when a coroutine can reach a blocking call, how deep is it?
+
+```
+depth 1 | ########################################   77  (48.7%)   <- a per-file linter sees these
+depth 2 | ###############                            28  (17.7%)
+depth 3 | ################                           31  (19.6%)
+depth 4 | #########                                  17  (10.8%)
+depth 5 | ##                                          3  ( 1.9%)
+depth 6 | #                                           2  ( 1.3%)
+
+        |                                           158 reachable blocking call sites
+```
+
+**51% of them sit at depth 2 or deeper**, across module boundaries, where no per-file linter can
+follow. As a cross-check, `ruff --select ASYNC` run on the same repositories flags **0 of those
+81 deep sites**. The histogram, and the fact that it rebuilds from scratch, is in
+[benchmark/depth_histogram.md](benchmark/depth_histogram.md) (`make bench-depth`).
+
+## What it looks like
+
+![blockpath check finding a blocking call through three files](docs/demo.svg)
+
+```console
+$ blockpath check .
+BLK001 blocking call reachable from a coroutine
+  app/handlers/order.py:11    return resolve_address(address)                     <- entry: async def
+    app/services/geo.py:6       return geocode(query)
+      app/clients/nominatim.py:7  response = requests.get(BASE_URL, params=...)   <- blocks the event loop
+  hint: await asyncio.to_thread(resolve_address, ...)
+
+1 finding(s): 1 BLK001
+```
+
+The path through three files is the point: no existing linter prints it.
+
+## Quick start
+
+```bash
+pip install blockpath
+blockpath check .
+blockpath check . --json      # for CI
+```
+
+Exit code is `0` when clean, `1` when there are findings (fails a build), `2` if the tool itself
+errored -- so a crash is never mistaken for a clean run.
+
+Optional configuration, in your own `pyproject.toml`:
+
+```toml
+[tool.blockpath]
+tiers = ["error"]                       # error (default) | warning | off
+entry-decorators = ["router.message"]   # mark framework handlers as entry points
+strict = false                          # also report blocking calls handed to unresolved callees
+```
+
+## How it works
+
+Six layers, each a small tested unit, and one idea that carries the whole thing.
+
+```
+collect  ->  symbols  ->  resolve  ->  callgraph  ->  oracle  ->  analysis
+(walk &      (names &     (name ->     (CALL/REF    (what      (three BFS,
+ parse)       scopes)      function)    edges)       blocks)    the witness)
+```
+
+The idea is that a finding is the **intersection of two independent reachability questions**, and
+that intersection is why the tool stays quiet:
+
+1. **Backward** from every blocking leaf: which functions can reach a blocking call at all?
+2. **Forward** from every coroutine: which functions can a coroutine reach?
+3. A third pass over the intersection recovers the *witness* -- the exact chain of call sites.
+
+Report only their intersection and `time.sleep` in a synchronous CLI script in the same repo
+stays silent. Report either half alone and the tool cries wolf and gets switched off. The whole
+analysis is `O(V+E)` -- three breadth-first searches, no Tarjan, no SCC, no fixpoint
+([ADR 0002](docs/adr/0002-three-bfs-not-tarjan.md)).
+
+The call graph is built from the AST **without importing or running your code**, so a project
+that needs a database to import is analysed the same as any other.
+
+## How good is it, honestly
+
+Run over five of the surveyed repositories and adjudicated by hand, finding by finding, with a
+second pass auditing the riskiest calls ([benchmark/adjudication.md](benchmark/adjudication.md)):
+
+- **precision 110/112 = 98.2%** by the tool's literal claim (a blocking call reachable from a
+  coroutine), of which 99 are product-code bugs and 11 are real blocking calls in test code; or
+  **99/112 = 88.4%** counting product bugs only. Both numbers are in the table, and each of the
+  two false positives is explained with a permalink.
+- **recall is a lower bound, never a point estimate.** The runtime verifier (`blockpath verify --
+  pytest`) records which functions actually ran on the loop and compares them to the static
+  findings, but it only sees the paths the tests exercised. It can prove a miss and can never
+  prove completeness, and it says nothing about precision -- only the hand adjudication does.
+
+Precision is not a number the analyzer asserts about itself; it is what survived a human reading
+each finding against the source.
+
+## Design decisions, and where it loses
+
+- **Only calls by name are resolved.** An attribute call on a value (`self.session.get()`) needs
+  type inference, which this does not do; the cost is measured (about half of all call sites on
+  one benchmark repo) rather than waved away ([ADR 0003](docs/adr/0003-attribute-calls-not-resolved.md)).
+- **A reference is not a call.** A function passed to `run_in_executor(None, f)` runs in a
+  thread, so it is silent by construction -- no offload false positives -- while
+  `run_in_executor(None, f())` with parentheses is a real bug (BLK002)
+  ([ADR 0007](docs/adr/0007-call-edges-only-ref-not-traversed.md)).
+- **Unknown is quiet by default.** A path with an unresolved edge is not reported unless you ask
+  with `--strict` (BLK003) ([ADR 0006](docs/adr/0006-reexport-and-star-import-policy.md)).
+- The [complete list of limitations](docs/limitations.md) is written as they were found, not at
+  the end.
+
+### Prior art
+
+- **ruff `ASYNC` rules** are written in Rust and run hundreds of times faster than this. They are
+  the right tool for the depth-1 case, and blockpath does not try to compete on speed. They work
+  per file, by an explicit architectural choice (parallel analysis without global state), so they
+  do not build a cross-module call graph and cannot print the path -- which is the entire reason
+  this exists. The 0-of-81 cross-check above is that difference, measured.
+- **flake8-async** is likewise per-file and does not follow calls between modules.
+
+blockpath is not a replacement for either; it is the cross-module analysis they deliberately do
+not do.
+
+## Development
+
+```bash
+uv sync --all-extras
+make check          # ruff, mypy --strict, pytest
+make bench-depth    # rebuild the depth histogram from the pinned corpus
+./scripts/reproduce_benchmark.sh   # rebuild the precision findings
+```
+
+This project is AI-assisted: written by a human, who made the product and architecture decisions
+and signed off at every checkpoint, with an AI pair implementing under direction. [WORKLOG.md](WORKLOG.md)
+keeps the estimate-versus-actual log from day one, including where the estimates were wrong.
+
+Python 3.12+ (it uses `sys.monitoring`, [ADR 0001](docs/adr/0001-python-312-only.md)). MIT licensed.

blockpath-0.1.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+blockpath/__init__.py,sha256=Z-ehpFXhOEezlzBADOTc5oEc66PlJ56C44aX2hor5rc,601
+blockpath/analysis.py,sha256=Rfpac1ZdSmgD1ELQ-MBbmYrhBC0DFji54m93wO0QjaQ,12665
+blockpath/callgraph.py,sha256=WDCbkUZH7jVYpgDqq2k6eML0njRlu3zWy1RqkLCmnxQ,11933
+blockpath/check.py,sha256=IHMx2d1oor75V8pS5VO8U3UHq-_k1IbIhxoRWRwamIE,1502
+blockpath/cli.py,sha256=Rphiv0eDNeM-4rwFRX-QkIn7FHX8nTA46OY6j-BUKhQ,5352
+blockpath/collect.py,sha256=H2kvjCfpFWUtwrAv5ybeOoAGi4KxaO6TI7bbSLrquuI,7367
+blockpath/config.py,sha256=PlgolhAt4nGWGr8QEzFHAuF02yRBs3OxbUguKU5p2vw,3000
+blockpath/model.py,sha256=HV3RAu4kMe5wwsB8BMpz2XE4ZKSxpQ8uoCtAc_Lxzgg,3680
+blockpath/oracle.py,sha256=6qFJgAPQSFYkB1pf9Ax6lE_H936mXsjmUTGZsaJNe0w,5418
+blockpath/oracle.yaml,sha256=8Vx9GONVCZIB36mc8W79yD-Is4dJw6kgDcKSV2EW2mE,7096
+blockpath/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+blockpath/report.py,sha256=N3bIq1WdQpJdBSoDCoxhnIKYyxl1s6o0l2IU0TWNV24,5114
+blockpath/resolve.py,sha256=777qsYtcmNhXbEm2X60nhCp0nb3zslH78PKVm5rqpEs,7377
+blockpath/symbols.py,sha256=tIY247bPNRiTRcW1TFaI8nBQQoZCoR9Mf14f3kt4Ajc,11619
+blockpath/runtime/__init__.py,sha256=NdD3fEJObRg7rSQjNJaNET6oM_Ny4AJ4kp1hFGZU_hg,1201
+blockpath/runtime/monitor.py,sha256=7-q8BdH6WhVRAc4jQjZpH6HZZ1tsRnr601xFEXaC5NM,5868
+blockpath/runtime/predicate.py,sha256=TgkzxaVqnB5LABs2hpVTTZHA0Di84dTWpZUkzdvPGcE,1782
+blockpath/runtime/verify.py,sha256=4na-QZ4ybMA2oFOIDP0vpGieOLWcPim_Ru_d-hGKJfE,6784
+blockpath/runtime/watchdog.py,sha256=I7iyGEH-KO395OxWTcRGpNxE_BcXrsFytJzvlHNeq-U,4408
+blockpath-0.1.0.dist-info/METADATA,sha256=ktb_SMES4zTAdyGliIu1kH3FpQheJgQMjaNVKAehg3o,8767
+blockpath-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+blockpath-0.1.0.dist-info/entry_points.txt,sha256=YS-kJTUwO3fttQt9HpRR5G6iJZwKgmKoJHEyDwofSkE,49
+blockpath-0.1.0.dist-info/licenses/LICENSE,sha256=Q7ngUffbbZwscUKxWkTT4rIlx8HUsW5Z27spnkTNsJQ,1062
+blockpath-0.1.0.dist-info/RECORD,,

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

blockpath-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+blockpath = blockpath.cli:main

blockpath-0.1.0.dist-info/licenses/LICENSE

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