nullscope 0.1.0__py3-none-any.whl

nullscope/__init__.py

@@ -0,0 +1,327 @@
+"""Nullscope: Zero-cost telemetry for Python.
+
+Provides ultra-low overhead no-op behavior when disabled and rich, contextual
+metrics when enabled via environment flags.
+"""
+
+import logging
+import os
+import re
+import time
+from collections import deque
+from collections.abc import Iterator
+from contextlib import AbstractContextManager, contextmanager
+from contextvars import ContextVar
+from dataclasses import dataclass
+from types import TracebackType
+from typing import Any, Final, Protocol, TypeAlias, TypedDict, runtime_checkable
+
+log = logging.getLogger(__name__)
+
+# Context-aware state for thread/async safety
+_scope_stack_var: ContextVar[tuple[str, ...]] = ContextVar(
+    "scope_stack",
+    default=(),
+)
+_call_count_var: ContextVar[int] = ContextVar("call_count", default=0)
+
+# Minimal-overhead optimization - evaluated once at import time
+# Nullscope is enabled only via explicit env toggle to avoid unintended overhead
+_NULLSCOPE_ENABLED = os.getenv("NULLSCOPE_ENABLED") == "1"
+_STRICT_SCOPES = os.getenv("NULLSCOPE_STRICT") == "1"
+
+# Built-in metadata keys (exported for clarity & resilience)
+DEPTH: Final[str] = "depth"
+PARENT_SCOPE: Final[str] = "parent_scope"
+CALL_COUNT: Final[str] = "call_count"
+METRIC_TYPE: Final[str] = "metric_type"
+START_MONOTONIC_S: Final[str] = "start_monotonic_s"  # High-precision monotonic seconds
+END_MONOTONIC_S: Final[str] = "end_monotonic_s"
+START_WALL_TIME_S: Final[str] = "start_wall_time_s"  # Epoch seconds (correlation)
+END_WALL_TIME_S: Final[str] = "end_wall_time_s"
+
+_SCOPE_NAME_PATTERN = re.compile(r"^[a-z][a-z0-9_]*(?:\.[a-z][a-z0-9_]*)*$")
+
+
+class _TelemetryMetadata(TypedDict, total=False):
+    depth: int
+    call_count: int
+    parent_scope: str | None
+    start_monotonic_s: float
+    end_monotonic_s: float
+    start_wall_time_s: float
+    end_wall_time_s: float
+
+
+@runtime_checkable
+class TelemetryReporter(Protocol):
+    """Duck-typed protocol for telemetry reporters."""
+
+    def record_timing(self, scope: str, duration: float, **metadata: Any) -> None: ...  # noqa: D102
+    def record_metric(self, scope: str, value: Any, **metadata: Any) -> None: ...  # noqa: D102
+
+
+@dataclass(frozen=True, slots=True)
+class _NoOpTelemetryContext:
+    """An immutable and stateless no-op context, optimized for negligible overhead."""
+
+    def __call__(self, name: str, **metadata: Any) -> "_NoOpTelemetryContext":  # noqa: ARG002
+        return self  # Self is already a context manager
+
+    def __enter__(self) -> "_NoOpTelemetryContext":
+        return self
+
+    def __exit__(
+        self,
+        _: type[BaseException] | None,
+        __: BaseException | None,
+        ___: TracebackType | None,
+    ) -> bool | None:
+        return None
+
+    @property
+    def is_enabled(self) -> bool:
+        return False
+
+    def metric(self, name: str, value: Any, **metadata: Any) -> None:
+        pass
+
+    def time(self, name: str, **metadata: Any) -> "_NoOpTelemetryContext":  # noqa: ARG002
+        return self
+
+    def count(self, name: str, increment: int = 1, **metadata: Any) -> None:
+        pass
+
+    def gauge(self, name: str, value: float, **metadata: Any) -> None:
+        pass
+
+
+class _EnabledTelemetryContext:
+    """Full-featured telemetry context when enabled."""
+
+    __slots__ = ("reporters",)
+
+    def __init__(self, *reporters: TelemetryReporter):
+        self.reporters = reporters
+
+    def __call__(
+        self, name: str, **metadata: Any
+    ) -> AbstractContextManager["_EnabledTelemetryContext"]:
+        return self._create_scope(name, **metadata)
+
+    @contextmanager
+    def _create_scope(
+        self, name: str, **metadata: Any
+    ) -> Iterator["_EnabledTelemetryContext"]:
+        """The actual scope implementation when enabled."""
+        if not name or not isinstance(name, str):
+            raise ValueError("Scope name must be a non-empty string")
+        if _STRICT_SCOPES and not _SCOPE_NAME_PATTERN.fullmatch(name):
+            raise ValueError(
+                "Invalid scope name. Use lowercase letters, digits, and underscores; "
+                "segments separated by dots.",
+            )
+
+        scope_stack = _scope_stack_var.get()
+        call_count = _call_count_var.get()
+        scope_path = ".".join((*scope_stack, name))
+        start_monotonic_s = time.perf_counter()
+        start_wall_time_s = time.time()
+
+        scope_token = _scope_stack_var.set((*scope_stack, name))
+        count_token = _call_count_var.set(call_count + 1)
+
+        try:
+            yield self  # Return self so chained methods work
+        finally:
+            end_monotonic_s = time.perf_counter()
+            duration = end_monotonic_s - start_monotonic_s
+            end_wall_time_s = start_wall_time_s + duration
+            _scope_stack_var.reset(scope_token)
+            _call_count_var.reset(count_token)
+
+            final_stack = _scope_stack_var.get()
+            final_count = _call_count_var.get()
+
+            built: _TelemetryMetadata = {
+                "depth": len(final_stack),
+                "call_count": final_count,
+                "parent_scope": ".".join(final_stack) if final_stack else None,
+                "start_monotonic_s": start_monotonic_s,
+                "end_monotonic_s": end_monotonic_s,
+                "start_wall_time_s": start_wall_time_s,
+                "end_wall_time_s": end_wall_time_s,
+            }
+            enhanced_metadata: dict[str, Any] = {**built, **metadata}
+
+            for reporter in self.reporters:
+                try:
+                    reporter.record_timing(scope_path, duration, **enhanced_metadata)
+                except Exception as e:
+                    log.error(
+                        "Telemetry reporter '%s' failed: %s",
+                        type(reporter).__name__,
+                        e,
+                        exc_info=True,
+                    )
+
+    def metric(self, name: str, value: Any, **metadata: Any) -> None:
+        """Record a metric within current scope context."""
+        scope_stack = _scope_stack_var.get()
+        scope_path = ".".join((*scope_stack, name))
+        built: _TelemetryMetadata = {
+            "depth": len(scope_stack),
+            "parent_scope": ".".join(scope_stack) if scope_stack else None,
+        }
+        enhanced_metadata: dict[str, Any] = {**built, **metadata}
+        for reporter in self.reporters:
+            try:
+                reporter.record_metric(scope_path, value, **enhanced_metadata)
+            except Exception as e:
+                log.error(
+                    "Telemetry reporter '%s' failed: %s",
+                    type(reporter).__name__,
+                    e,
+                    exc_info=True,
+                )
+
+    # Convenience methods for chaining
+    def time(
+        self, name: str, **metadata: Any
+    ) -> AbstractContextManager["_EnabledTelemetryContext"]:
+        """Alias for scope() - more intuitive for timing operations."""
+        return self(name, **metadata)
+
+    def count(self, name: str, increment: int = 1, **metadata: Any) -> None:
+        """Record a counter metric."""
+        self.metric(name, increment, metric_type="counter", **metadata)
+
+    def gauge(self, name: str, value: float, **metadata: Any) -> None:
+        """Record a gauge metric."""
+        self.metric(name, value, metric_type="gauge", **metadata)
+
+    @property
+    def is_enabled(self) -> bool:
+        return True
+
+
+_NO_OP_SINGLETON = _NoOpTelemetryContext()
+
+TelemetryContextProtocol: TypeAlias = _EnabledTelemetryContext | _NoOpTelemetryContext
+
+
+def TelemetryContext(*reporters: TelemetryReporter) -> TelemetryContextProtocol:  # noqa: N802
+    """Return a telemetry context.
+
+    Behavior:
+    - When nullscope is enabled (``NULLSCOPE_ENABLED=1``), return an enabled
+      context. If no reporters are provided, install a default in-memory
+      ``SimpleReporter`` for convenience.
+    - When nullscope is disabled, return a shared no-op instance for negligible
+      overhead.
+    """
+    if _NULLSCOPE_ENABLED:
+        reps = reporters or (SimpleReporter(),)
+        return _EnabledTelemetryContext(*reps)
+    # Always return the same, pre-existing no-op instance.
+    return _NO_OP_SINGLETON
+
+
+class SimpleReporter:
+    """Built-in reporter for development and debugging.
+
+    Collects telemetry in memory for inspection. Not intended for production use.
+    To view collected data, call `print_report()` or `get_report()`.
+    """
+
+    def __init__(self, max_entries_per_scope: int = 1000):
+        self.max_entries = max_entries_per_scope
+        self.timings: dict[str, deque[tuple[float, dict[str, Any]]]] = {}
+        self.metrics: dict[str, deque[tuple[Any, dict[str, Any]]]] = {}
+
+    def record_timing(self, scope: str, duration: float, **metadata: Any) -> None:
+        if scope not in self.timings:
+            self.timings[scope] = deque(maxlen=self.max_entries)
+        self.timings[scope].append((duration, metadata))
+
+    def record_metric(self, scope: str, value: Any, **metadata: Any) -> None:
+        if scope not in self.metrics:
+            self.metrics[scope] = deque(maxlen=self.max_entries)
+        self.metrics[scope].append((value, metadata))
+
+    def print_report(self) -> None:
+        """Prints the report to stdout if any data was collected."""
+        if self.timings or self.metrics:
+            print(self.get_report())  # noqa: T201
+
+    def reset(self) -> None:
+        """Clear all collected telemetry (testing convenience)."""
+        self.timings.clear()
+        self.metrics.clear()
+
+    def as_dict(self) -> dict[str, Any]:
+        """Return a JSON-serializable snapshot of collected data (testing)."""
+        return {
+            "timings": {key: list(values) for key, values in self.timings.items()},
+            "metrics": {key: list(values) for key, values in self.metrics.items()},
+        }
+
+    def get_report(self) -> str:
+        """Generate hierarchical telemetry report."""
+        lines = ["=== Nullscope Report ===\n"]
+
+        # Group by hierarchy
+        timing_tree = self._build_hierarchy(self.timings)
+        self._format_tree(timing_tree, lines, "Timings")
+
+        if self.metrics:
+            lines.append("\n--- Metrics ---")
+            for scope, values in sorted(self.metrics.items()):
+                total = sum(v[0] for v in values if isinstance(v[0], int | float))
+                lines.append(
+                    f"{scope:<40} | Count: {len(values):<4} | Total: {total:,.0f}",
+                )
+
+        return "\n".join(lines)
+
+    def _build_hierarchy(
+        self,
+        data: dict[str, deque[tuple[float, dict[str, Any]]]],
+    ) -> dict[str, Any]:
+        """Build tree structure from dot-separated scope names."""
+        tree: dict[str, Any] = {}
+        for scope, values in data.items():
+            parts = scope.split(".")
+            current = tree
+            for part in parts[:-1]:
+                current = current.setdefault(part, {})
+            current[parts[-1]] = values
+        return tree
+
+    def _format_tree(
+        self,
+        tree: dict[str, Any],
+        lines: list[str],
+        title: str,
+        depth: int = 0,
+    ) -> None:
+        """Format hierarchical tree with indentation."""
+        if depth == 0:
+            lines.append(f"\n--- {title} ---")
+
+        for key, value in sorted(tree.items()):
+            indent = "  " * depth
+            if isinstance(value, dict):
+                lines.append(f"{indent}{key}:")
+                self._format_tree(value, lines, title, depth + 1)
+            else:
+                # Leaf node - actual timing data
+                durations = [v[0] for v in value]
+                avg_time = sum(durations) / len(durations)
+                total_time = sum(durations)
+                lines.append(
+                    f"{indent}{key:<30} | "
+                    f"Calls: {len(durations):<4} | "
+                    f"Avg: {avg_time:.4f}s | "
+                    f"Total: {total_time:.4f}s",
+                )

nullscope/adapters/opentelemetry.py

@@ -0,0 +1,103 @@
+"""OpenTelemetry adapter for Nullscope reporters.
+
+This adapter intentionally keeps a small surface area:
+- timings -> Histogram (seconds), optional synthetic Span
+- counters -> Counter
+- gauges -> Histogram (sampled values distribution)
+"""
+
+from collections.abc import Mapping
+from typing import Any
+
+from nullscope import TelemetryReporter
+
+try:
+    from opentelemetry import metrics, trace
+except ModuleNotFoundError:  # pragma: no cover - exercised in runtime environments
+    metrics = None  # type: ignore[assignment]
+    trace = None  # type: ignore[assignment]
+
+
+def _sanitize_attributes(
+    attributes: Mapping[str, Any],
+) -> dict[str, bool | str | bytes | int | float]:
+    """Convert metadata into OpenTelemetry-compatible attribute values."""
+    out: dict[str, bool | str | bytes | int | float] = {}
+    for key, value in attributes.items():
+        if value is None:
+            continue
+        if isinstance(value, bool | str | bytes | int | float):
+            out[key] = value
+            continue
+        out[key] = str(value)
+    return out
+
+
+class OTelReporter(TelemetryReporter):
+    """Minimal OpenTelemetry adapter for metrics-first telemetry export."""
+
+    def __init__(self, service_name: str = "nullscope"):
+        """Create a reporter bound to the given OpenTelemetry service name."""
+        if trace is None or metrics is None:
+            raise RuntimeError(
+                "OpenTelemetry is not installed. "
+                "Install optional dependency: nullscope[otel]",
+            )
+        self.tracer = trace.get_tracer(service_name)
+        self.meter = metrics.get_meter(service_name)
+        self._histograms: dict[tuple[str, str], Any] = {}
+        self._counters: dict[str, Any] = {}
+
+    def record_timing(self, scope: str, duration: float, **metadata: Any) -> None:
+        """Record timing as a histogram sample and optional synthetic span."""
+        attributes = _sanitize_attributes(metadata)
+        self._get_timing_histogram(scope).record(duration, attributes=attributes)
+
+        start_s = metadata.get("start_wall_time_s")
+        end_s = metadata.get("end_wall_time_s")
+        if isinstance(start_s, int | float) and isinstance(end_s, int | float):
+            start_ns = int(start_s * 1e9)
+            end_ns = int(end_s * 1e9)
+            if end_ns >= start_ns:
+                span = self.tracer.start_span(
+                    scope,
+                    start_time=start_ns,
+                    attributes=attributes,
+                )
+                span.end(end_time=end_ns)
+
+    def record_metric(self, scope: str, value: Any, **metadata: Any) -> None:
+        """Record `counter` and `gauge` metrics using OpenTelemetry instruments."""
+        metric_type = metadata.get("metric_type", "counter")
+        attributes = _sanitize_attributes(metadata)
+
+        if metric_type == "counter" and isinstance(value, int | float) and value >= 0:
+            self._get_counter(scope).add(value, attributes=attributes)
+            return
+
+        if metric_type == "gauge" and isinstance(value, int | float):
+            # OTel sync Gauge support is limited in Python; record value samples instead.
+            self._get_value_histogram(scope).record(value, attributes=attributes)
+
+    def _get_timing_histogram(self, scope: str) -> Any:
+        key = ("timing", scope)
+        histogram = self._histograms.get(key)
+        if histogram is None:
+            histogram = self.meter.create_histogram(scope, unit="s")
+            self._histograms[key] = histogram
+        return histogram
+
+    def _get_value_histogram(self, scope: str) -> Any:
+        key = ("value", scope)
+        histogram = self._histograms.get(key)
+        if histogram is None:
+            histogram = self.meter.create_histogram(scope)
+            self._histograms[key] = histogram
+        return histogram
+
+    def _get_counter(self, scope: str) -> Any:
+        counter = self._counters.get(scope)
+        if counter is None:
+            counter = self.meter.create_counter(scope)
+            self._counters[scope] = counter
+        return counter

nullscope-0.1.0.dist-info/METADATA

@@ -0,0 +1,190 @@
+Metadata-Version: 2.4
+Name: nullscope
+Version: 0.1.0
+Summary: Zero-cost telemetry for Python. No-op when disabled, rich context when enabled.
+Project-URL: Homepage, https://github.com/seanbrar/nullscope
+Project-URL: Repository, https://github.com/seanbrar/nullscope
+Project-URL: Documentation, https://github.com/seanbrar/nullscope/tree/main/docs
+Project-URL: Issues, https://github.com/seanbrar/nullscope/issues
+Author-email: Sean Brar <hello@seanbrar.com>
+License: MIT
+License-File: LICENSE
+Keywords: metrics,nullscope,observability,telemetry,tracing,zero-cost
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: System :: Monitoring
+Classifier: Typing :: Typed
+Requires-Python: <3.15,>=3.10
+Provides-Extra: otel
+Requires-Dist: opentelemetry-api>=1.20.0; extra == 'otel'
+Description-Content-Type: text/markdown
+
+# Nullscope
+
+[![PyPI](https://img.shields.io/pypi/v/nullscope)](https://pypi.org/project/nullscope/)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+Zero-cost telemetry for Python. No-op when disabled, rich context when enabled.
+
+## Why Nullscope?
+
+Most telemetry libraries have runtime cost even when you don't need them. Nullscope is different:
+
+- **Disabled**: Returns a singleton no-op object. No allocations, no timing calls, no overhead.
+- **Enabled**: Full-featured timing and metrics with automatic scope hierarchy.
+
+This makes Nullscope ideal for **libraries** (users can enable telemetry if they want) and **applications** where you want zero production overhead but rich debugging capability.
+
+```python
+from nullscope import TelemetryContext
+
+# When NULLSCOPE_ENABLED != "1", this is literally just returning a cached object
+telemetry = TelemetryContext()
+
+with telemetry("database.query"):  # No-op when disabled
+    results = db.execute(query)
+```
+
+## What Nullscope Is Not
+
+- **A distributed tracing system.** No trace propagation, no span IDs, no context injection for cross-service correlation. If you need that, use OpenTelemetry directly. Nullscope can *feed* OTel, but it doesn't replace it.
+
+- **A metrics aggregation layer.** Nullscope reports raw events to reporters. It doesn't compute percentiles, histograms, or roll up data. That's the reporter's job (or the backend's).
+
+- **Auto-instrumentation.** Nullscope won't patch your HTTP client or database driver. You instrument what you want, explicitly.
+
+- **A logging framework.** Scopes are for timing and metrics, not structured log events. (Though a reporter *could* emit logs.)
+
+## Installation
+
+```bash
+pip install nullscope
+```
+
+With OpenTelemetry support:
+
+```bash
+pip install nullscope[otel]
+```
+
+## Quick Start
+
+```python
+import os
+os.environ["NULLSCOPE_ENABLED"] = "1"  # Enable telemetry
+
+from nullscope import TelemetryContext, SimpleReporter
+
+# Create a reporter to see output
+reporter = SimpleReporter()
+telemetry = TelemetryContext(reporter)
+
+# Time operations with automatic hierarchy
+with telemetry("request"):
+    with telemetry("auth"):
+        validate_token()
+
+    with telemetry("handler"):
+        process_data()
+
+# See what was collected
+reporter.print_report()
+```
+
+Output:
+
+```text
+=== Nullscope Report ===
+
+--- Timings ---
+request:
+  auth                           | Calls: 1    | Avg: 0.0012s | Total: 0.0012s
+  handler                        | Calls: 1    | Avg: 0.0234s | Total: 0.0234s
+```
+
+## Configuration
+
+| Environment Variable  | Description                          |
+| --------------------- | ------------------------------------ |
+| `NULLSCOPE_ENABLED=1` | Enable telemetry (default: disabled) |
+
+Note: environment flags are read at import time. In tests, reload `nullscope` after changing env vars.
+
+## API
+
+### TelemetryContext
+
+```python
+from nullscope import TelemetryContext
+
+telemetry = TelemetryContext()  # Uses default SimpleReporter when enabled
+telemetry = TelemetryContext(my_reporter)  # Custom reporter
+telemetry = TelemetryContext(reporter1, reporter2)  # Multiple reporters
+```
+
+### Scopes (Timing)
+
+```python
+with telemetry("operation"):
+    do_work()
+
+# With metadata
+with telemetry("http.request", method="GET", path="/api/users"):
+    handle_request()
+```
+
+### Metrics
+
+```python
+telemetry.count("cache.hit")  # Increment counter
+telemetry.count("items.processed", 5)  # Increment by N
+telemetry.gauge("queue.depth", len(queue))  # Point-in-time value
+telemetry.metric("custom", value, metric_type="counter")  # Generic
+```
+
+### Check Status
+
+```python
+if telemetry.is_enabled:
+    # Do expensive debug logging
+    pass
+```
+
+## OpenTelemetry Adapter
+
+Export to OpenTelemetry backends:
+
+```python
+from nullscope import TelemetryContext
+from nullscope.adapters.opentelemetry import OTelReporter
+
+# Configure OTel SDK first (providers, exporters, etc.)
+# Then use Nullscope with OTel reporter
+telemetry = TelemetryContext(OTelReporter(service_name="my-service"))
+```
+
+The adapter emits:
+
+- **Timings** → Histogram (seconds) + synthetic Span when wall-clock bounds are present
+- **Counters** → Counter
+- **Gauges** → Histogram (sampled values, since Python OTel sync gauge support is limited)
+
+## Documentation
+
+- [Design](docs/design.md) - Architecture and implementation details
+- [Examples](docs/examples.md) - Real-world usage patterns
+- [Comparison](docs/comparison.md) - When to use Nullscope vs alternatives
+- [Roadmap](ROADMAP.md) - Version milestones and planned features
+
+## License
+
+[MIT](LICENSE)

nullscope-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+nullscope/__init__.py,sha256=MtjVLpIm1l5wQNSqOIKcNXjTXRX8dtl8MldfWn4ZxTs,11911
+nullscope/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nullscope/adapters/opentelemetry.py,sha256=beyAyDP8IsGj_ZSlT24PMjcR8QLEDzYoQBn0-EZQN90,4080
+nullscope-0.1.0.dist-info/METADATA,sha256=8VCMRVWZ-c5UZRrTJAtwZey7Ys1rAKmM1p6CkVOjJfI,5898
+nullscope-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+nullscope-0.1.0.dist-info/licenses/LICENSE,sha256=C1VP2iuJoqm33UVgrb-73a-ofh40p4zf2vXbs8jubDk,1066
+nullscope-0.1.0.dist-info/RECORD,,

nullscope-0.1.0.dist-info/WHEEL

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

nullscope-0.1.0.dist-info/licenses/LICENSE

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