lakeview-cli 0.1.0__py3-none-any.whl

lakeview/__init__.py

@@ -0,0 +1,3 @@
+"""Local data inspection without a warehouse."""
+
+__version__ = "0.1.0"

lakeview/__main__.py

@@ -0,0 +1,4 @@
+from lakeview.cli import app
+
+if __name__ == "__main__":
+    app()

lakeview/cli.py

@@ -0,0 +1,174 @@
+"""Terminal entry points and stable automation exit codes."""
+
+from __future__ import annotations
+
+import json
+import sys
+from collections.abc import Callable, Iterator
+from contextlib import contextmanager
+from enum import StrEnum
+from io import TextIOWrapper
+from typing import TYPE_CHECKING, Annotated, Any
+
+import typer
+from rich.console import Console
+from rich.table import Table
+from rich.text import Text
+
+from lakeview import __version__
+from lakeview.formatters.markdown import clean, markdown
+from lakeview.formatters.terminal import render
+
+if TYPE_CHECKING:
+    from lakeview.core.engine import Engine
+
+# Windows redirected streams may default to cp1252; reports are UTF-8.
+if sys.platform == "win32":
+    for stream in (sys.stdout, sys.stderr):
+        if isinstance(stream, TextIOWrapper):
+            stream.reconfigure(encoding="utf-8", errors="replace")
+
+app = typer.Typer(
+    no_args_is_help=True,
+    pretty_exceptions_enable=False,
+    help="Local data profiling, exact diffs, and streaming SQL.",
+)
+console = Console(highlight=False)
+errors = Console(stderr=True, highlight=False)
+
+
+class Format(StrEnum):
+    terminal = "terminal"
+    json = "json"
+    markdown = "markdown"
+
+
+class QueryFormat(StrEnum):
+    terminal = "terminal"
+    jsonl = "jsonl"
+
+
+@contextmanager
+def guarded() -> Iterator[None]:
+    import duckdb
+    import pyarrow as pa
+
+    from lakeview.core.engine import LakeviewError
+
+    try:
+        yield
+    except (LakeviewError, duckdb.Error, pa.ArrowException, OSError, ValueError) as exc:
+        errors.print(Text(f"Error: {exc}", style="red"))
+        raise typer.Exit(2) from None
+
+
+def output(
+    run: Callable[[Engine], dict[str, Any]], fmt: Format, memory_limit: str, threads: int
+) -> dict[str, Any]:
+    from lakeview.core.engine import Engine
+
+    with guarded(), Engine(memory_limit, threads) as engine:
+        with errors.status("Scanning local data…") if errors.is_terminal else _quiet():
+            report = clean(run(engine))
+        if fmt == Format.json:
+            typer.echo(json.dumps(report, ensure_ascii=True, allow_nan=False, default=str))
+        elif fmt == Format.markdown:
+            typer.echo(markdown(report), nl=False)
+        else:
+            render(report, console)
+        return dict(report)
+
+
+@contextmanager
+def _quiet() -> Iterator[None]:
+    yield
+
+
+def version(value: bool) -> None:
+    if value:
+        typer.echo(__version__)
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version_flag: Annotated[
+        bool, typer.Option("--version", callback=version, is_eager=True)
+    ] = False,
+) -> None:
+    """Inspect local data with DuckDB. No service, account, or warehouse."""
+
+
+@app.command()
+def profile(
+    file: str, format: Format = Format.terminal, memory_limit: str = "512MB", threads: int = 4
+) -> None:
+    """Profile a file (or database.duckdb::schema.table)."""
+    from lakeview.core.profiler import profile as summarize
+
+    output(lambda e: summarize(e, file), format, memory_limit, threads)
+
+
+@app.command()
+def diff(
+    source: str,
+    target: str,
+    on: Annotated[
+        str | None, typer.Option(help="Comma-separated unique keys; NULL matches NULL.")
+    ] = None,
+    format: Format = Format.terminal,
+    fail_on_change: bool = False,
+    memory_limit: str = "512MB",
+    threads: int = 4,
+) -> None:
+    """Compare source → target; --fail-on-change returns 1 for differences, 2 for errors."""
+    from lakeview.core.differ import diff as compare
+
+    keys = [k.strip() for k in on.split(",")] if on is not None else None
+    report = output(lambda e: compare(e, source, target, keys), format, memory_limit, threads)
+    if fail_on_change and report["different"]:
+        raise typer.Exit(1)
+
+
+@app.command()
+def query(
+    sql: str,
+    files: Annotated[list[str] | None, typer.Argument()] = None,
+    format: QueryFormat = QueryFormat.terminal,
+    limit: Annotated[
+        int, typer.Option(min=1, help="Terminal display limit; JSONL streams all rows.")
+    ] = 100,
+    memory_limit: str = "512MB",
+    threads: int = 4,
+) -> None:
+    """Run one SELECT. File aliases: f1, f2, …; data aliases f1. JSONL streams all rows."""
+    from lakeview.core.engine import Engine
+
+    with guarded(), Engine(memory_limit, threads) as engine:
+        for i, spec in enumerate(files or [], 1):
+            engine.load(spec, f"f{i}")
+        if files:
+            engine.con.execute("CREATE VIEW data AS SELECT * FROM f1")
+        if format == QueryFormat.jsonl:
+            for batch in engine.query(sql):
+                for row in batch:
+                    typer.echo(
+                        json.dumps(clean(row), allow_nan=False, ensure_ascii=True, default=str)
+                    )
+        else:
+            rows: list[dict[str, Any]] = []
+            for batch in engine.query(sql, min(limit + 1, 8192)):
+                rows.extend(batch[: limit + 1 - len(rows)])
+                if len(rows) > limit:
+                    break
+            table = Table(title="lakeview · query")
+            if rows:
+                for name in rows[0]:
+                    table.add_column(Text(name))
+                for row in rows[:limit]:
+                    table.add_row(*(Text(str(value)) for value in row.values()))
+                console.print(table)
+            console.print(
+                f"{min(len(rows), limit)} rows shown"
+                + (" (truncated; use --format jsonl for all rows)" if len(rows) > limit else "")
+            )

lakeview/core/__init__.py

@@ -0,0 +1 @@
+"""Streaming execution, profiling, and exact comparison."""

lakeview/core/differ.py

@@ -0,0 +1,136 @@
+"""Exact bag comparisons and null-safe, unique-key row comparisons."""
+
+from __future__ import annotations
+
+import time
+from typing import Any
+
+from lakeview.core.engine import Engine, LakeviewError, ident, numeric
+
+
+def metrics(engine: Engine, table: str, columns: list[str]) -> dict[str, dict[str, Any]]:
+    if not columns:
+        return {}
+    expressions: list[str] = []
+    scales = engine.scales(table, columns)
+    for name in columns:
+        value = f"CASE WHEN isfinite({ident(name)}::DOUBLE) THEN {ident(name)}::DOUBLE END"
+        scale = scales[name]
+        expressions.extend(
+            [
+                f"avg(({value})/{scale!r})*{scale!r}",
+                f"var_pop(({value})/{scale!r})*{scale!r}*{scale!r}",
+                f"min({value})",
+                f"max({value})",
+            ]
+        )
+    row = engine.con.execute(f"SELECT {', '.join(expressions)} FROM {ident(table)}").fetchone()
+    assert row is not None
+    return {
+        name: dict(zip(("mean", "variance", "min", "max"), row[i * 4 : i * 4 + 4], strict=True))
+        for i, name in enumerate(columns)
+    }
+
+
+def diff(engine: Engine, source: str, target: str, keys: list[str] | None = None) -> dict[str, Any]:
+    started = time.perf_counter()
+    engine.load(source, "src")
+    engine.load(target, "dst")
+    left, right = engine.schema("src"), engine.schema("dst")
+    common = [name for name in left if name in right]
+    added_columns = {name: right[name] for name in right if name not in left}
+    removed_columns = {name: left[name] for name in left if name not in right}
+    changed_types = {
+        name: {"source": left[name], "target": right[name]}
+        for name in common
+        if left[name] != right[name]
+    }
+    counts = {
+        table: int(engine.scalar(f"SELECT count(*) FROM {table}")) for table in ("src", "dst")
+    }
+    comparable = [name for name in common if left[name] == right[name]]
+    unchanged = 0
+    modified: int | None = None
+    if keys:
+        if len(keys) != len(set(keys)):
+            raise LakeviewError("Join keys must not be repeated.")
+        for key in keys:
+            if key not in comparable:
+                raise LakeviewError(f"Key {key!r} must exist on both sides with identical types.")
+        key_sql = ", ".join(ident(k) for k in keys)
+        for table in ("src", "dst"):
+            if engine.scalar(
+                f"SELECT EXISTS (SELECT 1 FROM {table} GROUP BY {key_sql} HAVING count(*) > 1)"
+            ):
+                raise LakeviewError(
+                    f"Duplicate keys in {table}; use unique keys or omit --on for bag comparison."
+                )
+        join = " AND ".join(f"s.{ident(k)} IS NOT DISTINCT FROM t.{ident(k)}" for k in keys)
+        shared_values = [name for name in comparable if name not in keys]
+        changes = (
+            " OR ".join(f"s.{ident(c)} IS DISTINCT FROM t.{ident(c)}" for c in shared_values)
+            or "false"
+        )
+        matched, modified_raw = engine.con.execute(
+            f"SELECT count(*), count(*) FILTER (WHERE {changes}) FROM src s JOIN dst t ON {join}"
+        ).fetchone() or (0, 0)
+        modified = int(modified_raw)
+        unchanged = int(matched) - modified
+        added, removed = counts["dst"] - int(matched), counts["src"] - int(matched)
+    else:
+        if set(left) != set(right) or changed_types:
+            added, removed = counts["dst"], counts["src"]
+        else:
+            cols = ", ".join(ident(c) for c in left)
+            removed = int(
+                engine.scalar(
+                    f"SELECT count(*) FROM (SELECT {cols} FROM src "
+                    f"EXCEPT ALL SELECT {cols} FROM dst)"
+                )
+            )
+            added = int(
+                engine.scalar(
+                    f"SELECT count(*) FROM (SELECT {cols} FROM dst "
+                    f"EXCEPT ALL SELECT {cols} FROM src)"
+                )
+            )
+            unchanged = counts["src"] - removed
+    metric_names = [name for name in common if numeric(left[name]) and numeric(right[name])]
+    source_metrics, target_metrics = (
+        metrics(engine, "src", metric_names),
+        metrics(engine, "dst", metric_names),
+    )
+    drift = {
+        name: {
+            "source": source_metrics[name],
+            "target": target_metrics[name],
+            "delta": {
+                stat: (
+                    target_metrics[name][stat] - source_metrics[name][stat]
+                    if source_metrics[name][stat] is not None
+                    and target_metrics[name][stat] is not None
+                    else None
+                )
+                for stat in source_metrics[name]
+            },
+        }
+        for name in metric_names
+    }
+    schema_changed = bool(added_columns or removed_columns or changed_types)
+    return {
+        "source": source,
+        "target": target,
+        "mode": "keyed" if keys else "multiset",
+        "keys": keys or [],
+        "source_rows": counts["src"],
+        "target_rows": counts["dst"],
+        "added": added,
+        "removed": removed,
+        "modified": modified,
+        "unchanged": unchanged,
+        "schema": {"added": added_columns, "removed": removed_columns, "changed": changed_types},
+        "compared_columns": comparable if keys else list(left),
+        "metrics": drift,
+        "different": schema_changed or bool(added or removed or modified),
+        "elapsed_ms": round((time.perf_counter() - started) * 1000, 3),
+    }

lakeview/core/engine.py

@@ -0,0 +1,165 @@
+"""Bounded DuckDB execution over local, read-only input datasets."""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Iterator
+from contextlib import AbstractContextManager
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from types import TracebackType
+from typing import Any
+
+import duckdb
+import pyarrow as pa
+import pyarrow.dataset as ds
+import pyarrow.ipc as ipc
+
+
+class LakeviewError(Exception):
+    """An actionable user-facing error."""
+
+
+def ident(value: str) -> str:
+    return '"' + value.replace('"', '""') + '"'
+
+
+def literal(value: str) -> str:
+    return "'" + value.replace("'", "''") + "'"
+
+
+def numeric(dtype: str) -> bool:
+    return bool(
+        re.match(r"^(U?(TINYINT|SMALLINT|INTEGER|BIGINT|HUGEINT)|FLOAT|DOUBLE|DECIMAL)", dtype)
+    )
+
+
+class Engine(AbstractContextManager["Engine"]):
+    """Ephemeral database with disk spill; memory_limit is not a total RSS cap."""
+
+    def __init__(self, memory_limit: str = "512MB", threads: int = 4) -> None:
+        if not re.fullmatch(r"[1-9][0-9]*(?:\.[0-9]+)?(?:KB|MB|GB|TB)", memory_limit.upper()):
+            raise LakeviewError("Memory limit must look like 512MB or 2GB.")
+        if threads < 1:
+            raise LakeviewError("Threads must be positive.")
+        self.temp = TemporaryDirectory(prefix="lakeview-")
+        self.resources: list[Any] = []
+        self.databases: dict[Path, str] = {}
+        try:
+            self.con = duckdb.connect(
+                ":memory:",
+                config={
+                    "memory_limit": memory_limit,
+                    "threads": threads,
+                    "temp_directory": self.temp.name,
+                    "preserve_insertion_order": False,
+                    "autoinstall_known_extensions": False,
+                    "autoload_known_extensions": False,
+                },
+            )
+        except Exception:
+            self.temp.cleanup()
+            raise
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        self.con.close()
+        for resource in reversed(self.resources):
+            resource.close()
+        self.temp.cleanup()
+
+    def scalar(self, sql: str) -> Any:
+        row = self.con.execute(sql).fetchone()
+        if row is None:
+            raise LakeviewError("Query did not return a result.")
+        return row[0]
+
+    def schema(self, alias: str) -> dict[str, str]:
+        return {
+            str(row[0]): str(row[1])
+            for row in self.con.execute(f"DESCRIBE {ident(alias)}").fetchall()
+        }
+
+    def scales(self, alias: str, columns: list[str]) -> dict[str, float]:
+        """Finite magnitudes for stable aggregation without intermediate overflow."""
+        if not columns:
+            return {}
+        expressions = [
+            f"max(abs({ident(c)}::DOUBLE)) FILTER (WHERE isfinite({ident(c)}::DOUBLE))"
+            for c in columns
+        ]
+        row = self.con.execute(f"SELECT {', '.join(expressions)} FROM {ident(alias)}").fetchone()
+        assert row is not None
+        return {c: float(v) if v else 1.0 for c, v in zip(columns, row, strict=True)}
+
+    def load(self, spec: str, alias: str) -> Path:
+        raw, sep, table = spec.partition("::")
+        path = Path(raw).expanduser().resolve()
+        if not path.is_file():
+            raise LakeviewError(f"File not found: {path}")
+        suffix = path.suffix.lower()
+        quoted = literal(str(path))
+        if suffix in {".duckdb", ".db"}:
+            database = self.databases.get(path, f"db_{alias}")
+            if path not in self.databases:
+                self.con.execute(f"ATTACH {quoted} AS {ident(database)} (READ_ONLY)")
+                self.databases[path] = database
+            tables = self.con.execute(
+                "SELECT table_schema, table_name FROM information_schema.tables "
+                "WHERE table_catalog = ? AND table_type = 'BASE TABLE' ORDER BY 1, 2",
+                [database],
+            ).fetchall()
+            if sep:
+                matches = [(s, t) for s, t in tables if table in (t, f"{s}.{t}")]
+            else:
+                matches = tables
+            if len(matches) != 1:
+                available = ", ".join(f"{s}.{t}" for s, t in tables)
+                raise LakeviewError(
+                    f"Choose one table with file.duckdb::schema.table. Available: {available}"
+                )
+            schema, name = matches[0]
+            source = f"{ident(database)}.{ident(schema)}.{ident(name)}"
+        elif sep:
+            raise LakeviewError("The ::table selector is only supported for DuckDB files.")
+        elif suffix in {".parquet", ".pq"}:
+            source = f"read_parquet({quoted})"
+        elif suffix in {".csv", ".tsv"}:
+            delimiter = "\t" if suffix == ".tsv" else ","
+            source = f"read_csv({quoted}, header=true, delim={literal(delimiter)}, sample_size=-1)"
+        elif suffix in {".arrow", ".ipc", ".feather"}:
+            handle = pa.memory_map(str(path), "r")
+            self.resources.append(handle)
+            try:
+                ipc.open_file(handle)
+            except pa.ArrowInvalid:
+                import pyarrow.parquet as pq
+
+                handle.seek(0)
+                reader = ipc.open_stream(handle)
+                converted = Path(self.temp.name) / f"{alias}.parquet"
+                with pq.ParquetWriter(str(converted), reader.schema) as writer:
+                    for batch in reader:
+                        writer.write_batch(batch)
+                source = f"read_parquet({literal(str(converted))})"
+            else:
+                self.con.register(f"arrow_{alias}", ds.dataset(str(path), format="ipc"))
+                source = ident(f"arrow_{alias}")
+        else:
+            raise LakeviewError(
+                f"Unsupported file extension: {suffix}. Use Parquet, CSV, TSV, DuckDB, or IPC."
+            )
+        self.con.execute(f"CREATE VIEW {ident(alias)} AS SELECT * FROM {source}")
+        return path
+
+    def query(self, sql: str, batch_size: int = 8192) -> Iterator[list[dict[str, Any]]]:
+        statements = self.con.extract_statements(sql)
+        if len(statements) != 1 or statements[0].type != duckdb.StatementType.SELECT:
+            raise LakeviewError("query accepts exactly one SELECT (including WITH).")
+        reader = self.con.execute(sql).to_arrow_reader(batch_size)
+        for batch in reader:
+            yield batch.to_pylist()

lakeview/core/profiler.py

@@ -0,0 +1,86 @@
+"""Exact counts and finite-value statistics, with approximate quantiles."""
+
+from __future__ import annotations
+
+import time
+from typing import Any
+
+import psutil
+
+from lakeview.core.engine import Engine, ident, numeric
+
+
+def profile(engine: Engine, spec: str) -> dict[str, Any]:
+    started = time.perf_counter()
+    path = engine.load(spec, "data")
+    schema = engine.schema("data")
+    scales = engine.scales("data", [c for c, dtype in schema.items() if numeric(dtype)])
+    expressions = ["count(*)"]
+    for name, dtype in schema.items():
+        col = ident(name)
+        expressions.append(f"count(*) - count({col})")
+        if numeric(dtype):
+            value = f"CASE WHEN isfinite({col}::DOUBLE) THEN {col}::DOUBLE END"
+            scale = scales[name]
+            expressions.extend(
+                [
+                    f"count({col}) - count({value})",
+                    f"avg(({value})/{scale!r})*{scale!r}",
+                    f"var_pop(({value})/{scale!r})*{scale!r}*{scale!r}",
+                    f"min({value})",
+                    f"max({value})",
+                    f"approx_quantile({value}, [0.25, 0.5, 0.75])",
+                ]
+            )
+    row = engine.con.execute("SELECT " + ", ".join(expressions) + " FROM data").fetchone()
+    assert row is not None
+    count, cursor = int(row[0]), 1
+    columns: list[dict[str, Any]] = []
+    histograms: list[str] = []
+    histogram_columns: list[dict[str, Any]] = []
+    for name, dtype in schema.items():
+        nulls = int(row[cursor])
+        cursor += 1
+        column: dict[str, Any] = {
+            "name": name,
+            "type": dtype,
+            "nulls": nulls,
+            "null_percent": 100 * nulls / count if count else 0.0,
+        }
+        if numeric(dtype):
+            for field in ("nonfinite", "mean", "variance", "min", "max", "quantiles"):
+                column[field] = row[cursor]
+                cursor += 1
+            low, high = column["min"], column["max"]
+            column["histogram"] = [0] * 8
+            if low is not None:
+                col = f"{ident(name)}::DOUBLE"
+                if high == low:
+                    bucket = "0"
+                else:
+                    scale = max(abs(low), abs(high), 1.0)
+                    bucket = (
+                        f"least(7, greatest(0, floor((({col}/{scale!r}) - "
+                        f"({low!r}/{scale!r})) / "
+                        f"(({high!r}/{scale!r}) - ({low!r}/{scale!r})) * 8)))"
+                    )
+                for i in range(8):
+                    histograms.append(
+                        f"count(*) FILTER (WHERE isfinite({col}) AND ({bucket}) = {i})"
+                    )
+                histogram_columns.append(column)
+        columns.append(column)
+    if histograms:
+        bins = engine.con.execute("SELECT " + ", ".join(histograms) + " FROM data").fetchone()
+        assert bins is not None
+        for index, column in enumerate(histogram_columns):
+            column["histogram"] = list(bins[index * 8 : index * 8 + 8])
+    return {
+        "file": str(path),
+        "rows": count,
+        "file_bytes": path.stat().st_size,
+        "process_rss_bytes": psutil.Process().memory_info().rss,
+        "columns": columns,
+        "quantiles": "approximate",
+        "elapsed_ms": round((time.perf_counter() - started) * 1000, 3),
+    }

lakeview/formatters/__init__.py

@@ -0,0 +1 @@
+"""Human and machine readable reports."""

lakeview/formatters/markdown.py

@@ -0,0 +1,103 @@
+"""Portable reports with escaped data-controlled Markdown cells."""
+
+from __future__ import annotations
+
+import html
+import math
+from typing import Any
+
+
+def clean(value: Any) -> Any:
+    """Convert non-finite results to JSON null, recursively."""
+    if isinstance(value, float) and not math.isfinite(value):
+        return None
+    if isinstance(value, dict):
+        return {str(k): clean(v) for k, v in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [clean(v) for v in value]
+    return value
+
+
+def cell(value: Any) -> str:
+    text = "—" if value is None else str(value)
+    return (
+        html.escape(text)
+        .replace("|", "|")
+        .replace("\r", " ")
+        .replace("\n", " ")
+        .replace("`", "`")
+    )
+
+
+def markdown(report: dict[str, Any]) -> str:
+    if "schema" in report:
+        lines = [
+            "## lakeview data diff",
+            "",
+            "| Added | Removed | Modified | Unchanged |",
+            "| ---: | ---: | ---: | ---: |",
+            "| "
+            + " | ".join(cell(report[k]) for k in ("added", "removed", "modified", "unchanged"))
+            + " |",
+            "",
+            f"Mode: {report['mode']}. Modified is unavailable in multiset mode.",
+            "",
+            "### Schema drift",
+            "",
+            "| Change | Column | Type |",
+            "| --- | --- | --- |",
+        ]
+        for kind, columns in report["schema"].items():
+            for name, dtype in columns.items():
+                lines.append(f"| {cell(kind)} | {cell(name)} | {cell(dtype)} |")
+        lines.extend(
+            [
+                "",
+                "### Numerical drift (finite values)",
+                "",
+                "| Column | Statistic | Source | Target | Delta |",
+                "| --- | --- | ---: | ---: | ---: |",
+            ]
+        )
+        for name, values in report["metrics"].items():
+            for stat in ("mean", "variance", "min", "max"):
+                lines.append(
+                    "| "
+                    + " | ".join(
+                        cell(v)
+                        for v in (
+                            name,
+                            stat,
+                            values["source"][stat],
+                            values["target"][stat],
+                            values["delta"][stat],
+                        )
+                    )
+                    + " |"
+                )
+        lines.extend(
+            [
+                "",
+                "Row comparisons use shared columns with identical types; "
+                "schema changes are separate.",
+            ]
+        )
+    else:
+        lines = [
+            "## lakeview profile",
+            "",
+            f"Rows: {report['rows']:,}. File bytes: {report['file_bytes']:,}.",
+            "",
+            "| Column | Type | Null % | Mean | Min | Max | Approx. Q25/Q50/Q75 |",
+            "| --- | --- | ---: | ---: | ---: | ---: | --- |",
+        ]
+        for col in report["columns"]:
+            lines.append(
+                "| "
+                + " | ".join(
+                    cell(col.get(k))
+                    for k in ("name", "type", "null_percent", "mean", "min", "max", "quantiles")
+                )
+                + " |"
+            )
+    return "\n".join(lines) + "\n"

lakeview/formatters/terminal.py

@@ -0,0 +1,85 @@
+"""Compact Rich reports; data values are never interpreted as markup."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from rich.console import Console
+from rich.table import Table
+from rich.text import Text
+
+
+def number(value: Any) -> str:
+    return "—" if value is None else f"{value:.5g}" if isinstance(value, float) else str(value)
+
+
+def sparkline(bins: list[int]) -> str:
+    maximum = max(bins, default=0)
+    return "".join("▁▂▃▄▅▆▇█"[round(v / maximum * 7)] for v in bins) if maximum else "────────"
+
+
+def render(report: dict[str, Any], console: Console) -> None:
+    if "schema" in report:
+        table = Table(title="lakeview · semantic diff")
+        for name, color in (
+            ("Added", "green"),
+            ("Removed", "red"),
+            ("Modified", "yellow"),
+            ("Unchanged", "cyan"),
+        ):
+            table.add_column(name, style=color, justify="right")
+        table.add_row(*(number(report[k]) for k in ("added", "removed", "modified", "unchanged")))
+        console.print(table)
+        schema = Table("Change", "Column", "Type", title="Schema drift")
+        for kind, columns in report["schema"].items():
+            for name, dtype in columns.items():
+                schema.add_row(Text(kind), Text(name), Text(str(dtype)))
+        if schema.row_count:
+            console.print(schema)
+        drift = Table(
+            "Column",
+            "Statistic",
+            "Source",
+            "Target",
+            "Delta",
+            title="Numerical drift · finite values",
+        )
+        for name, values in report["metrics"].items():
+            for stat in ("mean", "variance", "min", "max"):
+                drift.add_row(
+                    Text(name),
+                    stat,
+                    *(number(values[side][stat]) for side in ("source", "target", "delta")),
+                )
+        if drift.row_count:
+            console.print(drift)
+        console.print(
+            "Mode: " + report["mode"] + ". Schema changes reported separately; "
+            "values compared on shared identical-type columns.",
+            markup=False,
+        )
+    else:
+        console.print(
+            f"lakeview · {report['rows']:,} rows · {report['file_bytes']:,} file bytes",
+            markup=False,
+        )
+        console.print(f"Process RSS after scan: {report['process_rss_bytes'] / 1024**2:.1f} MiB")
+        table = Table(
+            "Column", "Type", "Null %", "Mean", "Min / Max", "Q25 / Q50 / Q75 ≈", "Distribution"
+        )
+        for col in report["columns"]:
+            table.add_row(
+                Text(col["name"]),
+                col["type"],
+                f"{col['null_percent']:.2f}",
+                number(col.get("mean")),
+                f"{number(col.get('min'))} / {number(col.get('max'))}",
+                " / ".join(number(v) for v in (col.get("quantiles") or [])),
+                sparkline(col.get("histogram", [])),
+            )
+        console.print(table)
+        console.print(
+            "Counts exact · quantiles approximate · statistics exclude NaN/Infinity · "
+            "file bytes are not RAM usage"
+        )
+    console.print(f"Completed in {report['elapsed_ms']:,.1f} ms", style="dim")

lakeview_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,230 @@
+Metadata-Version: 2.5
+Name: lakeview-cli
+Version: 0.1.0
+Summary: Local data profiling, exact semantic diffs, and streaming SQL with DuckDB
+Project-URL: Homepage, https://github.com/Karthikvk1899/lakeview
+Project-URL: Issues, https://github.com/Karthikvk1899/lakeview/issues
+Author: Karthik Beesa
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: cli,data-engineering,diff,duckdb,parquet
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: duckdb<2,>=1.4
+Requires-Dist: psutil<8,>=6
+Requires-Dist: pyarrow<24,>=19
+Requires-Dist: rich<15,>=13.9
+Requires-Dist: typer<1,>=0.16
+Provides-Extra: benchmark
+Requires-Dist: pandas<4,>=2.2; extra == 'benchmark'
+Description-Content-Type: text/markdown
+
+# lakeview — The missing CLI for local data profiling, semantic diffing, and fast SQL.
+
+[![CI](https://github.com/Karthikvk1899/lakeview/actions/workflows/ci.yml/badge.svg)](https://github.com/Karthikvk1899/lakeview/actions/workflows/ci.yml)
+[![Python 3.11+](https://img.shields.io/badge/python-3.11%2B-blue)](pyproject.toml)
+[![Apache 2.0](https://img.shields.io/badge/license-Apache--2.0-green)](LICENSE)
+
+Your dbt model ran. The row count looks fine. Something still changed.
+
+You can open a notebook, load two DataFrames, remember how to compare NULLs,
+then discover that duplicate rows broke your join. Or start a warehouse just
+to inspect two files already on your laptop.
+
+For the small-file, two-second check you wanted in the first place:
+
+```sh
+lakeview diff prod.parquet staging.parquet --on id
+```
+
+**Exact row comparisons. Duplicate-aware counts. Read-only inputs. No account.**
+
+![Actual Rich terminal output from the synthetic demo](docs/demo.svg)
+
+```diff
+$ lakeview diff prod.parquet staging.parquet --on id
++ added rows:      1
+- removed rows:    1
+! modified rows:   1
+  unchanged rows:  1
++ schema: region VARCHAR
+! revenue mean: 200.00 -> 316.67
+```
+
+The condensed example above comes from the three-row [demo generator](examples/make_demo.py).
+The CLI renders insertions in green, deletions in red, and modifications in yellow.
+
+## Install and try it
+
+Python 3.11 or newer. Install the tagged source now:
+
+```sh
+pip install "lakeview-cli @ git+https://github.com/Karthikvk1899/lakeview.git@v0.1.0"
+lakeview --help
+```
+
+Or install a wheel / download a platform bundle from [Releases](https://github.com/Karthikvk1899/lakeview/releases).
+The repository includes automated PyPI publishing, but registry publication requires
+maintainer setup. `pip install lakeview-cli` is only appropriate after this project's
+package has been published there. There is no Homebrew formula yet.
+
+```sh
+git clone https://github.com/Karthikvk1899/lakeview.git
+cd lakeview
+uv sync --locked
+uv run python examples/make_demo.py
+uv run lakeview profile demo/prod.parquet
+uv run lakeview diff demo/prod.parquet demo/staging.parquet --on id
+uv run lakeview query 'SELECT avg(revenue) FROM data' demo/staging.parquet
+```
+
+## Three commands, useful defaults
+
+| Command | What you get |
+| --- | --- |
+| `profile` | Schema, exact row/null counts, null rates, mean, population variance, min/max, approximate quartiles, eight-bin histograms, file size and process RSS |
+| `diff` | Schema additions/removals/type changes, exact row deltas, mean/variance/min/max drift |
+| `query` | DuckDB SELECT queries, bounded terminal previews, streaming JSONL output |
+
+```sh
+lakeview profile events.parquet --format json
+lakeview profile 'warehouse.duckdb::main.orders' --memory-limit 256MB
+lakeview diff yesterday.csv today.csv --on account_id,event_id --format markdown
+lakeview diff baseline.arrow candidate.arrow --fail-on-change
+lakeview query 'SELECT f1.id FROM f1 JOIN f2 USING (id)' left.parquet right.csv
+lakeview query 'SELECT * FROM data ORDER BY id' events.parquet --format jsonl > rows.jsonl
+```
+
+Formats: Parquet (`.parquet`, `.pq`), CSV/TSV with headers, DuckDB (`.duckdb`, `.db`),
+and Arrow IPC file/stream (`.arrow`, `.ipc`) / Feather V2 (`.feather`). A database
+with one table can omit the selector. With several tables, use `file.duckdb::schema.table`.
+The first query input is `f1` (also `data`), followed by `f2`, `f3`, etc.
+
+The terminal query preview defaults to 100 rows; change it with `--limit`.
+JSONL streams every row in batches of 8,192. Decimal/HUGEINT and temporal values
+serialize as strings to preserve precision. SQL NULL and non-finite floats become
+JSON `null`. Use ORDER BY when output order matters.
+
+## What does “different” mean?
+
+| Case | Behavior |
+| --- | --- |
+| With `--on` | Keys must exist with identical types and be unique on each side. Composite keys supported; NULL matches NULL. Duplicate keys produce an error instead of a many-to-many join. |
+| Without `--on` | Exact multiset comparison via `EXCEPT ALL`: duplicate multiplicities count. A changed row is a removal plus an addition; modified is unavailable. |
+| Column order | Ignored for equality. |
+| Schema drift with keys | Reported separately. Modified counts compare shared, identical-type non-key columns only. A changed-type column is not silently cast. |
+| Schema drift without keys | Incompatible schemas make all source rows removed and all target rows added. |
+| Floating values | Exact DuckDB equality for row comparisons, including its NaN semantics. No rounding or tolerance is applied. |
+| Numeric summaries | Finite values only, converted to DOUBLE; high-precision decimals/integers may round in statistics, but row comparisons retain their original types. |
+
+Exit codes: **0** success, **1** differences when `--fail-on-change` is enabled,
+**2** input, SQL, or execution error. Without `--fail-on-change`, a successful diff
+returns 0 even if data changed. Schema drift counts as a difference.
+
+## Performance, measured
+
+One million rows, three columns, 11.6 MB Parquet. Windows build 26200, eight logical
+CPUs, Python 3.11.15, DuckDB 1.5.6, Arrow 23.0.1, Pandas 3.0.6.
+Medians of three fresh processes; OS file cache may be warm. Peak RSS is sampled
+every 10 ms. [Raw samples](docs/benchmarks/windows-1m.json) and [benchmark script](benchmarks/run.py).
+
+| Workflow | Startup probe | Full operation | Peak RSS during operation |
+| --- | ---: | ---: | ---: |
+| lakeview | 382 ms (`--help`) | 1,314 ms (`profile --format json`) | 131.5 MiB |
+| Pandas | 737 ms (`import pandas`) | 995 ms (`read_parquet`, `describe`, null counts) | 173.4 MiB |
+| Spark | Not measured | Not measured | Not measured |
+
+These operations are not feature-equivalent: Pandas `describe` also computes distinct
+categorical summaries; lakeview computes histograms. Startup probes are different
+operations too. This fixture favors Pandas on elapsed time. lakeview's value is a
+ready-to-use CLI, explicit diff semantics, and a spill-capable engine.
+
+**There is no universal “under 200 ms” promise.** Full statistics require scans;
+storage, data shape, string width, CPU, and startup matter. Quantiles are approximate.
+CSV performs full-file type inference for consistent types, adding work. IPC streams
+are converted batchwise into temporary Parquet for repeatable scans.
+
+```sh
+uv run --extra benchmark python benchmarks/run.py --rows 1000000 --repeats 3
+```
+
+`--memory-limit` controls DuckDB's buffer manager, not total process RSS. Arrow,
+Python, and some engine allocations sit outside it. Large joins and sorts can spill
+to the temporary directory; adequate disk space is required. Resource exhaustion is
+reported as a CLI error, not a guarantee that every workload fits any memory limit.
+The profile's RSS is a process snapshot after scanning, not a peak measurement.
+
+A separate large-file smoke test profiled **2.49 GB of uncompressed Parquet**
+(1.2 million rows) in **3.10 seconds**, using `--memory-limit 128MB --threads 2`.
+Process RSS after scanning was 144.5 MiB. This fixture has a constant 2,048-byte
+string payload and benefits from column projection; it is not representative of
+all 2.49 GB files. [Raw result](docs/benchmarks/large-parquet.json).
+
+## Put the diff in a pull request
+
+The job below assumes your existing build produced `baseline.parquet` and
+`candidate.parquet` in the workspace. Use `pull_request`, never run untrusted PR
+code with a privileged `pull_request_target` token. Fork PRs generally cannot write
+comments with their read-only token; they can still retain a job summary.
+
+```yaml
+permissions:
+  contents: read
+  pull-requests: write
+steps:
+  - uses: actions/checkout@v4
+  - uses: actions/setup-python@v5
+    with:
+      python-version: '3.11'
+  - run: pip install "lakeview-cli @ git+https://github.com/Karthikvk1899/lakeview.git@v0.1.0"
+  - name: Compute report
+    shell: bash
+    run: |
+      lakeview diff baseline.parquet candidate.parquet --on id --format markdown > diff.md
+      cat diff.md >> "$GITHUB_STEP_SUMMARY"
+  - uses: actions/github-script@v7
+    if: github.event_name == 'pull_request' && github.event.pull_request.head.repo.fork == false
+    with:
+      script: |
+        const fs = require('fs');
+        const body = fs.readFileSync('diff.md', 'utf8');
+        await github.rest.issues.createComment({
+          ...context.repo,
+          issue_number: context.issue.number,
+          body: body.slice(0, 60000)
+        });
+  - name: Fail on data changes
+    run: lakeview diff baseline.parquet candidate.parquet --on id --fail-on-change
+```
+
+Reports can expose business aggregates. Review what is appropriate for your repository.
+Markdown report values are escaped and passed as file contents, not interpolated
+into executable JavaScript or shell commands.
+
+## Under the hood
+
+Each command owns an in-memory DuckDB connection and a temporary spill directory.
+Parquet/CSV scans stay in DuckDB; IPC files use Arrow Dataset scans. IPC streams are
+written one record batch at a time to temporary Parquet. DuckDB databases attach
+read-only. Normal exit closes resources and removes temporary files.
+
+Profiling computes finite magnitudes, aggregate statistics, then equal-width histogram
+bins in separate vectorized passes. Scaling prevents intermediate variance overflow;
+statistics outside representable floating-point range render as unavailable. Diffing
+uses exact comparisons, not hash equality. Python receives summaries or query batches,
+never a whole input DataFrame.
+
+See [architecture and limits](docs/architecture.md), [security](SECURITY.md), and
+[contributing](CONTRIBUTING.md). This is an initial beta release. It does not include
+remote storage, fuzzy matching, row samples, or automatic key discovery.
+
+## Help make local data work less tedious
+
+Try it on a real model output. Open an issue with a synthetic reproduction when the
+semantics surprise you. Contributions around datasets, profiling accuracy, and
+reproducible performance are especially useful. If it earns a place in your workflow,
+a star helps other data engineers find it.
+
+Apache-2.0. Built with [DuckDB](https://duckdb.org/) and [Apache Arrow](https://arrow.apache.org/).

lakeview_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+lakeview/__init__.py,sha256=V0T9QzL4VfSol_l-AMSBNMb56TAe4oWQnM0sOLB7QUg,72
+lakeview/__main__.py,sha256=9O9_ORluXXp5r8BvGfm7XZ242nU8srFHf-EA92I1QDQ,67
+lakeview/cli.py,sha256=TffGfy-4ED_OAiQhJfxgPb5TYjYFSWleCrPX3bR8wM8,5475
+lakeview/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lakeview/core/__init__.py,sha256=H6xilnOtqV2h0buDyZ0lz6DDOYtp7M8SwglGtvO_ed8,60
+lakeview/core/differ.py,sha256=krKMJR61Fjs-CSOB2ZHPt3GIxgbPCx6g62eeL2JuaHY,5465
+lakeview/core/engine.py,sha256=M0K3x-0_nkIOlWa-M2Fmo0v3RBMVQt7Hbx6uYNb-2Ng,6512
+lakeview/core/profiler.py,sha256=uD6iwZZ7rQfG5NHe6lGvbTd2Okfa_uiEquQ7cqklI1A,3351
+lakeview/formatters/__init__.py,sha256=Wd_lMGsCE7l0TEVLx1iLel3Z-TTkpuI3RtpP-8Y1Up8,42
+lakeview/formatters/markdown.py,sha256=QH9fDTH6eqFUoq1H5VGp6fEPTL-3-Jfn-3wUbTQhMhU,3319
+lakeview/formatters/terminal.py,sha256=VjDAHEoLM33Lit0lrSf38XRYJrf4skFzZCFLB9skxQk,3263
+lakeview_cli-0.1.0.dist-info/METADATA,sha256=mhDJ2BzJ9wm-pvXhXSwpAaCDDih7Zh7YG2vmyAxd_q8,11001
+lakeview_cli-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+lakeview_cli-0.1.0.dist-info/entry_points.txt,sha256=UWXg_MqvPOb5DZqJAeAg7Q-G6jndmTZz3Zwv8IL7Y20,46
+lakeview_cli-0.1.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+lakeview_cli-0.1.0.dist-info/RECORD,,

lakeview_cli-0.1.0.dist-info/WHEEL

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

lakeview_cli-0.1.0.dist-info/entry_points.txt

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

lakeview_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.