goldenanalysis 0.1.0__py3-none-any.whl

goldenanalysis/__init__.py

@@ -0,0 +1,61 @@
+"""GoldenAnalysis — read-only cross-cutting analysis/metrics/reporting for the Golden Suite.
+
+Public surface (Phase 1): the generic frame path.
+
+    import goldenanalysis as ga
+    report = ga.analyze(df, analyzers=["frame.summary"])
+    print(report.to_markdown())
+
+Suite adapters, the other analyzers, ``ReportHistory``/regression detection, the
+TypeScript port, and the Rust accelerator land in later phases.
+
+Public names are re-exported lazily (PEP 562) so the package imports cleanly even
+while submodules are still being built out.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "analyze",
+    "analyze_match",
+    "analyze_pipeline",
+    "AnalysisReport",
+    "Metric",
+    "ReportHistory",
+    "RegressionPolicy",
+    "__version__",
+]
+
+if TYPE_CHECKING:
+    from goldenanalysis._api import analyze, analyze_match, analyze_pipeline
+    from goldenanalysis.history import ReportHistory
+    from goldenanalysis.models import AnalysisReport, Metric, RegressionPolicy
+
+# Map exported name -> (submodule, attribute). Resolved on first access.
+_LAZY: dict[str, tuple[str, str]] = {
+    "analyze": ("goldenanalysis._api", "analyze"),
+    "analyze_match": ("goldenanalysis._api", "analyze_match"),
+    "analyze_pipeline": ("goldenanalysis._api", "analyze_pipeline"),
+    "AnalysisReport": ("goldenanalysis.models", "AnalysisReport"),
+    "Metric": ("goldenanalysis.models", "Metric"),
+    "ReportHistory": ("goldenanalysis.history", "ReportHistory"),
+    "RegressionPolicy": ("goldenanalysis.models", "RegressionPolicy"),
+}
+
+
+def __getattr__(name: str) -> Any:
+    target = _LAZY.get(name)
+    if target is None:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+    import importlib
+
+    module, attr = target
+    return getattr(importlib.import_module(module), attr)
+
+
+def __dir__() -> list[str]:
+    return sorted(__all__)

goldenanalysis/_api.py

@@ -0,0 +1,154 @@
+"""Top-level analyze entrypoints — resolve analyzers, run them over an artifact,
+assemble a single ``AnalysisReport``.
+
+- ``analyze(df, ...)`` — the generic frame path (Phase 1).
+- ``analyze_match(result, ...)`` / ``analyze_pipeline(result)`` — suite paths
+  (Phase 2a) over a GoldenMatch ``DedupeResult`` / GoldenPipe ``PipeResult``.
+
+Cross-run aggregation + narrative generation land in Phase 2b.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from datetime import UTC, datetime
+from typing import Any
+
+import polars as pl
+
+from goldenanalysis.adapters import FrameArtifactAdapter
+from goldenanalysis.models import AnalysisReport, AnalyzerInput
+from goldenanalysis.registry import available_analyzers, load_analyzer
+
+
+def _assemble_report(
+    inp: AnalyzerInput,
+    analyzer_names: Sequence[str],
+    *,
+    run_id: str | None = None,
+    generated_at: datetime | None = None,
+) -> AnalysisReport:
+    """Run ``analyzer_names`` over ``inp`` and assemble one ``AnalysisReport``.
+
+    Shared by every analyze entrypoint. Names that are requested but not
+    discoverable are recorded in ``source["unavailable"]`` rather than raising.
+    """
+    ds = inp.dataset
+    discoverable = set(available_analyzers())
+
+    ran: list[str] = []
+    unavailable: list[str] = []
+    metrics = []
+    tables = []
+    for name in analyzer_names:
+        if name not in discoverable:
+            unavailable.append(name)
+            continue
+        result = load_analyzer(name).run(inp)
+        metrics.extend(result.metrics)
+        tables.extend(result.tables)
+        ran.append(name)
+
+    gen = generated_at or datetime.now(UTC)
+    rid = run_id or f"{gen.isoformat()}#{ds}"
+    source = {"dataset": ds, "producer": inp.artifacts.get("__producer__", "frame")}
+    if unavailable:
+        source["unavailable"] = ",".join(unavailable)
+
+    return AnalysisReport(
+        run_id=rid,
+        generated_at=gen,
+        source=source,
+        metrics=metrics,
+        tables=tables,
+        narrative=None,
+        analyzers_run=ran,
+    )
+
+
+def _frame_compatible_analyzers() -> list[str]:
+    """Discoverable analyzers that consume a generic ``frame`` and import cleanly.
+
+    Loading is guarded so analyzers needing optional suite deps are simply skipped
+    from the default set rather than breaking the generic path.
+    """
+    out: list[str] = []
+    for name in available_analyzers():
+        try:
+            analyzer = load_analyzer(name)
+        except Exception:
+            continue
+        if "frame" in analyzer.info.consumes:
+            out.append(name)
+    return out
+
+
+def _artifact_compatible_analyzers(inp: AnalyzerInput) -> list[str]:
+    """Discoverable analyzers at least one of whose ``consumes`` keys is present
+    in ``inp.artifacts`` — the fan-out selector for ``analyze_pipeline``."""
+    present = set(inp.artifacts)
+    out: list[str] = []
+    for name in available_analyzers():
+        try:
+            analyzer = load_analyzer(name)
+        except Exception:
+            continue
+        if any(key in present for key in analyzer.info.consumes):
+            out.append(name)
+    return out
+
+
+def analyze(
+    df: pl.DataFrame,
+    analyzers: Sequence[str] | None = None,
+    *,
+    dataset: str | None = None,
+    run_id: str | None = None,
+    generated_at: datetime | None = None,
+) -> AnalysisReport:
+    """Run ``analyzers`` over ``df`` and return a single ``AnalysisReport``.
+
+    ``analyzers=None`` defaults to every frame-compatible analyzer. Names that are
+    requested but not discoverable are recorded in ``source["unavailable"]`` rather
+    than raising — the report says what it could and couldn't compute.
+    """
+    inp = FrameArtifactAdapter().load(df, dataset=dataset)
+    requested = list(analyzers) if analyzers is not None else _frame_compatible_analyzers()
+    return _assemble_report(inp, requested, run_id=run_id, generated_at=generated_at)
+
+
+def analyze_match(
+    result: Any,
+    *,
+    dataset: str | None = None,
+    certificate: Any = None,
+    run_id: str | None = None,
+    generated_at: datetime | None = None,
+) -> AnalysisReport:
+    """Analyze a GoldenMatch ``DedupeResult``: ``match.rates`` + ``cluster.distribution``.
+
+    ``certificate`` (optional) is a recall certificate — a ``{estimate, safe_bound}``
+    dict or a ``RecallEstimate``/``RecallCertificate``. When absent, the recall
+    metrics are omitted (graceful degradation).
+    """
+    from goldenanalysis.adapters.match import MatchArtifactAdapter
+
+    inp = MatchArtifactAdapter().load(result, dataset=dataset, certificate=certificate)
+    return _assemble_report(
+        inp, ["match.rates", "cluster.distribution"], run_id=run_id, generated_at=generated_at
+    )
+
+
+def analyze_pipeline(
+    result: Any,
+    *,
+    run_id: str | None = None,
+    generated_at: datetime | None = None,
+) -> AnalysisReport:
+    """Analyze a GoldenPipe ``PipeResult``, fanning out to every analyzer whose
+    consumed artifacts are present in ``result.artifacts``."""
+    from goldenanalysis.adapters.pipe import PipeArtifactAdapter
+
+    inp = PipeArtifactAdapter().load(result)
+    names = _artifact_compatible_analyzers(inp)
+    return _assemble_report(inp, names, run_id=run_id, generated_at=generated_at)

goldenanalysis/_regressions.py

@@ -0,0 +1,81 @@
+"""Pure regression decision logic — baseline strategy + direction-aware policy.
+
+Backend-free: operates on a list of ``(run_id, value)`` history points + the
+current value. ``ReportHistory`` wires storage around this.
+"""
+
+from __future__ import annotations
+
+import statistics
+from collections.abc import Sequence
+
+from goldenanalysis.models import Direction, RegressionPolicy
+
+
+def baseline_value(history: Sequence[float], strategy: str, *, window: int = 7) -> float | None:
+    """The baseline to compare the current value against.
+
+    - ``"previous"`` / ``"last_known_good"``: the most recent historical value
+      (v1: ``last_known_good`` aliases ``previous`` until a health signal exists).
+    - ``"rolling_median"``: median of the last ``window`` historical values — immune
+      to one noisy night, where ``previous`` would alternately flag and un-flag.
+    - any other string is treated as a pinned ``run_id`` and is resolved by the
+      caller (which has the run->value map); here it falls through to ``previous``.
+
+    Returns None when there's no history to compare against.
+    """
+    if not history:
+        return None
+    if strategy == "rolling_median":
+        tail = list(history[-window:])
+        return float(statistics.median(tail))
+    # "previous", "last_known_good", or a pinned id resolved upstream.
+    return float(history[-1])
+
+
+def delta_pct(baseline: float, current: float) -> float:
+    if baseline == 0:
+        return 0.0
+    return (current - baseline) / baseline * 100.0
+
+
+def is_regression(direction: Direction, baseline: float, current: float, threshold_pct: float) -> bool:
+    """Direction-aware: a higher_better metric flags only on a DROP beyond the
+    threshold; lower_better only on a RISE; neutral on either direction."""
+    d = delta_pct(baseline, current)
+    if direction == "higher_better":
+        return d <= -threshold_pct
+    if direction == "lower_better":
+        return d >= threshold_pct
+    return abs(d) >= threshold_pct
+
+
+def evaluate_metric(
+    *,
+    key: str,
+    direction: Direction,
+    history: Sequence[float],
+    current: float,
+    strategy: str,
+    window: int,
+    policy: RegressionPolicy,
+):
+    """Return a ``Regression`` for one metric, or None when there's no baseline.
+
+    ``flagged`` reflects the direction-aware per-metric gate; the record is always
+    returned (when a baseline exists) so callers can show near-misses if they want.
+    """
+    from goldenanalysis.models import Regression
+
+    base = baseline_value(history, strategy, window=window)
+    if base is None:
+        return None
+    threshold = policy.threshold_for(key)
+    return Regression(
+        metric=key,
+        baseline=base,
+        current=current,
+        delta_pct=delta_pct(base, current),
+        flagged=is_regression(direction, base, current, threshold),
+        direction=direction,
+    )

goldenanalysis/adapters/__init__.py

@@ -0,0 +1,11 @@
+"""Artifact adapters normalize a producer's output into an ``AnalyzerInput``.
+
+Phase 1 ships only the generic ``frame`` adapter (zero suite deps). Suite adapters
+(match/check/flow/pipe) land in Phase 2.
+"""
+
+from __future__ import annotations
+
+from goldenanalysis.adapters.frame import FrameArtifactAdapter
+
+__all__ = ["FrameArtifactAdapter"]

goldenanalysis/adapters/check.py

@@ -0,0 +1,33 @@
+"""``check`` adapter — GoldenCheck scan output → ``AnalyzerInput.artifacts``.
+
+Two entry points:
+- ``from_scan(findings, profile, ...)`` — pure, no ``goldencheck`` import (the seam
+  the unit tests and the pipe adapter use).
+- ``load(df, ...)`` — lazy-imports ``goldencheck`` and runs ``scan_dataframe``.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from goldenanalysis.models import AnalyzerInput
+
+
+class CheckArtifactAdapter:
+    """Normalizes GoldenCheck scan output into an ``AnalyzerInput``."""
+
+    def from_scan(self, findings: Any, profile: Any = None, *, dataset: str | None = None) -> AnalyzerInput:
+        return AnalyzerInput(
+            dataset=dataset or "check",
+            artifacts={"__producer__": "goldencheck", "findings": findings, "profile": profile},
+        )
+
+    def load(self, df: Any, *, dataset: str | None = None, **scan_kwargs: Any) -> AnalyzerInput:
+        try:
+            import goldencheck  # pyright: ignore[reportMissingImports]  # optional [check] extra
+        except ImportError as exc:  # pragma: no cover - exercised in CI with the extra
+            raise RuntimeError(
+                "goldenanalysis[check] requires goldencheck: pip install goldenanalysis[check]"
+            ) from exc
+        findings, profile = goldencheck.scan_dataframe(df, **scan_kwargs)
+        return self.from_scan(findings, profile, dataset=dataset)

goldenanalysis/adapters/flow.py

@@ -0,0 +1,25 @@
+"""``flow`` adapter — GoldenFlow ``TransformResult`` → ``AnalyzerInput.artifacts``.
+
+Duck-typed: reads ``.df`` and ``.manifest`` off the result; imports nothing from
+``goldenflow``.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from goldenanalysis.models import AnalyzerInput
+
+
+class FlowArtifactAdapter:
+    """Normalizes a GoldenFlow ``TransformResult`` into an ``AnalyzerInput``."""
+
+    def load(self, result: Any, *, dataset: str | None = None) -> AnalyzerInput:
+        return AnalyzerInput(
+            dataset=dataset or "flow",
+            frame=getattr(result, "df", None),
+            artifacts={
+                "__producer__": "goldenflow",
+                "manifest": getattr(result, "manifest", None),
+            },
+        )

goldenanalysis/adapters/frame.py

@@ -0,0 +1,18 @@
+"""The generic ``frame`` adapter — the always-available, zero-suite-dep path.
+
+Imports nothing from other suite packages, so GoldenAnalysis is useful on any
+polars DataFrame even with no other Golden package installed.
+"""
+
+from __future__ import annotations
+
+import polars as pl
+
+from goldenanalysis.models import AnalyzerInput
+
+
+class FrameArtifactAdapter:
+    """Normalizes a raw polars DataFrame into an ``AnalyzerInput``."""
+
+    def load(self, df: pl.DataFrame, *, dataset: str | None = None) -> AnalyzerInput:
+        return AnalyzerInput(frame=df, dataset=dataset or "frame")

goldenanalysis/adapters/match.py

@@ -0,0 +1,59 @@
+"""``match`` adapter — GoldenMatch ``DedupeResult`` → ``AnalyzerInput.artifacts``.
+
+Duck-typed: reads ``.clusters`` / ``.scored_pairs`` / ``.stats`` off the result,
+so it imports nothing from ``goldenmatch``. The recall certificate is optional —
+passed in by the caller, or read off ``result.recall_certificate`` when the
+producer attached one (``dedupe_df(..., certify=True)``).
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from goldenanalysis.models import AnalyzerInput
+
+
+def _normalize_cert(cert: Any) -> dict[str, Any] | None:
+    """Normalize a recall certificate to ``{estimate, safe_bound}`` (or None)."""
+    if cert is None:
+        return None
+    if isinstance(cert, dict):
+        return {
+            "estimate": cert.get("estimate", cert.get("recall")),
+            "safe_bound": cert.get("safe_bound", cert.get("recall_lower")),
+        }
+    return {
+        "estimate": getattr(cert, "recall", None),
+        "safe_bound": getattr(cert, "recall_lower", None),
+    }
+
+
+def _primary_threshold(config: Any) -> float | None:
+    """Best-effort: the first matchkey's threshold from the result's config."""
+    try:
+        matchkeys = config.get_matchkeys() if hasattr(config, "get_matchkeys") else getattr(config, "matchkeys", None)
+        for mk in matchkeys or []:
+            thr = getattr(mk, "threshold", None)
+            if thr is not None:
+                return float(thr)
+    except Exception:
+        return None
+    return None
+
+
+class MatchArtifactAdapter:
+    """Normalizes a GoldenMatch ``DedupeResult`` into an ``AnalyzerInput``."""
+
+    def load(self, result: Any, *, dataset: str | None = None, certificate: Any = None) -> AnalyzerInput:
+        cert = certificate if certificate is not None else getattr(result, "recall_certificate", None)
+        artifacts: dict[str, Any] = {
+            "__producer__": "goldenmatch",
+            "clusters": getattr(result, "clusters", {}) or {},
+            "scored_pairs": getattr(result, "scored_pairs", []) or [],
+            "match_stats": getattr(result, "stats", {}) or {},
+            "match_threshold": _primary_threshold(getattr(result, "config", None)),
+        }
+        normalized = _normalize_cert(cert)
+        if normalized is not None:
+            artifacts["recall_certificate"] = normalized
+        return AnalyzerInput(dataset=dataset or "match", artifacts=artifacts)

goldenanalysis/adapters/pipe.py

@@ -0,0 +1,36 @@
+"""``pipe`` adapter — GoldenPipe ``PipeResult`` → ``AnalyzerInput.artifacts``.
+
+Near-passthrough: ``PipeResult.artifacts`` already carries the per-stage outputs
+(findings / manifest / clusters / scored_pairs / match_stats / recall_certificate
+/ ...) under the same keys the analyzers read. Duck-typed; no ``goldenpipe`` import.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from goldenanalysis.adapters.match import _normalize_cert
+from goldenanalysis.models import AnalyzerInput
+
+
+def _dataset_from_source(source: Any) -> str:
+    if not source or not isinstance(source, str) or source.startswith("<"):
+        return "frame"
+    return Path(source).stem or "frame"
+
+
+class PipeArtifactAdapter:
+    """Normalizes a GoldenPipe ``PipeResult`` into an ``AnalyzerInput``."""
+
+    def load(self, result: Any, *, dataset: str | None = None) -> AnalyzerInput:
+        artifacts: dict[str, Any] = dict(getattr(result, "artifacts", {}) or {})
+        artifacts["__producer__"] = "goldenpipe"
+        if "recall_certificate" in artifacts:
+            normalized = _normalize_cert(artifacts["recall_certificate"])
+            if normalized is None:
+                artifacts.pop("recall_certificate", None)
+            else:
+                artifacts["recall_certificate"] = normalized
+        ds = dataset or _dataset_from_source(getattr(result, "source", None))
+        return AnalyzerInput(dataset=ds, artifacts=artifacts)

goldenanalysis/analyzers/__init__.py

@@ -0,0 +1,7 @@
+"""Analyzers: the composable units that compute metrics over an ``AnalyzerInput``."""
+
+from __future__ import annotations
+
+from goldenanalysis.analyzers.base import Analyzer
+
+__all__ = ["Analyzer"]

goldenanalysis/analyzers/base.py

@@ -0,0 +1,19 @@
+"""The ``Analyzer`` protocol.
+
+An analyzer is anything with an ``info`` descriptor and a ``run`` method. Concrete
+analyzers are discovered by the registry via the ``goldenanalysis.analyzers``
+entry-point group.
+"""
+
+from __future__ import annotations
+
+from typing import Protocol, runtime_checkable
+
+from goldenanalysis.models import AnalyzerInfo, AnalyzerInput, AnalyzerResult
+
+
+@runtime_checkable
+class Analyzer(Protocol):
+    info: AnalyzerInfo
+
+    def run(self, inp: AnalyzerInput) -> AnalyzerResult: ...

goldenanalysis/analyzers/cluster_dist.py

@@ -0,0 +1,77 @@
+"""``cluster.distribution`` — cluster-size shape from a GoldenMatch result.
+
+Reads ``clusters`` (and optionally ``match_stats`` for the record count) from
+``AnalyzerInput.artifacts``.
+"""
+
+from __future__ import annotations
+
+from goldenanalysis.core import aggregate as agg
+from goldenanalysis.models import (
+    AnalysisTable,
+    AnalyzerInfo,
+    AnalyzerInput,
+    AnalyzerResult,
+    Metric,
+)
+
+_PRODUCES = [
+    "cluster.count",
+    "cluster.record_count",
+    "cluster.singleton_ratio",
+    "cluster.size_p50",
+    "cluster.size_p95",
+    "cluster.size_max",
+    "cluster.reduction_ratio",
+]
+
+
+class ClusterDistributionAnalyzer:
+    """Cluster count, singleton ratio, size quantiles, reduction ratio, histogram."""
+
+    info = AnalyzerInfo(name="cluster.distribution", consumes=["clusters"], produces=_PRODUCES)
+
+    def run(self, inp: AnalyzerInput) -> AnalyzerResult:
+        clusters = inp.artifacts.get("clusters")
+        if not clusters:
+            return AnalyzerResult(metrics=[], tables=[])
+
+        sizes = [int(c.get("size", len(c.get("members", []))) if isinstance(c, dict) else c) for c in clusters.values()]
+        count = len(clusters)
+        # Prefer the engine's own record total; fall back to summed cluster sizes.
+        stats = inp.artifacts.get("match_stats", {}) or {}
+        record_count = int(stats.get("total_records", sum(sizes)))
+        singletons = sum(1 for s in sizes if s == 1)
+
+        metrics = [
+            Metric(key="cluster.count", value=count, unit="clusters", direction="neutral"),
+            Metric(key="cluster.record_count", value=record_count, unit="rows", direction="neutral"),
+            Metric(
+                key="cluster.singleton_ratio",
+                value=(singletons / count) if count else 0.0,
+                unit="ratio",
+                direction="neutral",
+            ),
+            Metric(key="cluster.size_p50", value=agg.quantile(sizes, 0.5), unit="rows", direction="neutral"),
+            Metric(key="cluster.size_p95", value=agg.quantile(sizes, 0.95), unit="rows", direction="neutral"),
+            Metric(key="cluster.size_max", value=max(sizes) if sizes else 0, unit="rows", direction="neutral"),
+            Metric(
+                key="cluster.reduction_ratio",
+                value=(1 - count / record_count) if record_count else 0.0,
+                unit="ratio",
+                direction="neutral",
+            ),
+        ]
+
+        # Discrete size histogram, buckets 1 / 2 / 3 / "4+".
+        n1 = sum(1 for s in sizes if s == 1)
+        n2 = sum(1 for s in sizes if s == 2)
+        n3 = sum(1 for s in sizes if s == 3)
+        n4 = sum(1 for s in sizes if s >= 4)
+        table = AnalysisTable(
+            name="cluster_size_histogram",
+            columns=["size", "count"],
+            rows=[[1, n1], [2, n2], [3, n3], ["4+", n4]],
+        )
+
+        return AnalyzerResult(metrics=metrics, tables=[table])

goldenanalysis/analyzers/frame_summary.py

@@ -0,0 +1,72 @@
+"""``frame.summary`` — generic frame metrics, zero suite deps, always available.
+
+Emits the Appendix-A metric set: row/column counts, mean null ratio, exact-
+duplicate-row ratio, estimated in-memory size, plus a ``per_column`` table
+(column, dtype, null_ratio, n_unique).
+"""
+
+from __future__ import annotations
+
+from goldenanalysis.core import aggregate as agg
+from goldenanalysis.models import (
+    AnalysisTable,
+    AnalyzerInfo,
+    AnalyzerInput,
+    AnalyzerResult,
+    Metric,
+)
+
+_PRODUCES = [
+    "frame.row_count",
+    "frame.column_count",
+    "frame.null_ratio_mean",
+    "frame.duplicate_row_ratio",
+    "frame.memory_bytes",
+]
+
+
+class FrameSummaryAnalyzer:
+    """Summarize a raw frame: shape, null mass, duplication, memory footprint."""
+
+    info = AnalyzerInfo(name="frame.summary", consumes=["frame"], produces=_PRODUCES)
+
+    def run(self, inp: AnalyzerInput) -> AnalyzerResult:
+        df = inp.frame
+        if df is None:
+            raise ValueError("frame.summary requires AnalyzerInput.frame (a polars DataFrame)")
+
+        n_rows = df.height
+        n_cols = df.width
+        null_ratios = agg.null_ratio_per_column(df)
+        null_mean = sum(null_ratios.values()) / n_cols if n_cols else 0.0
+        dup_ratio = agg.duplicate_row_ratio(df)
+        mem_bytes = df.estimated_size()
+
+        metrics = [
+            Metric(key="frame.row_count", value=n_rows, unit="rows", direction="neutral"),
+            Metric(key="frame.column_count", value=n_cols, unit="columns", direction="neutral"),
+            Metric(
+                key="frame.null_ratio_mean",
+                value=null_mean,
+                unit="ratio",
+                direction="lower_better",
+            ),
+            Metric(
+                key="frame.duplicate_row_ratio",
+                value=dup_ratio,
+                unit="ratio",
+                direction="lower_better",
+            ),
+            Metric(key="frame.memory_bytes", value=mem_bytes, unit="bytes", direction="neutral"),
+        ]
+
+        per_column = AnalysisTable(
+            name="per_column",
+            columns=["column", "dtype", "null_ratio", "n_unique"],
+            rows=[
+                [col, str(df[col].dtype), null_ratios[col], df[col].n_unique()]
+                for col in df.columns
+            ],
+        )
+
+        return AnalyzerResult(metrics=metrics, tables=[per_column])