oribi 0.1.0__tar.gz

oribi-0.1.0/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+All notable changes to Oribi are recorded here.
+
+## 0.1.0 — Initial release
+
+- Introduce the `oribi` pandas DataFrame profiling API.
+- Report column statistics, evidence-backed semantic roles, recommendations, warnings, relationships, candidate keys, and likely grain.
+- Add conservative temporal-gap warnings for regular datetime series.
+- Provide summary, dictionary, JSON, Markdown, and bounded AI-oriented context output.

oribi-0.1.0/LICENSE

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

oribi-0.1.0/MANIFEST.in

@@ -0,0 +1,4 @@
+include CHANGELOG.md
+include LICENSE
+include README.md
+include examples/quickstart.py

oribi-0.1.0/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: oribi
+Version: 0.1.0
+Summary: Evidence-backed analytical context for pandas DataFrames
+Author: Oribi contributors
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/samhoon000/Oribi
+Project-URL: Repository, https://github.com/samhoon000/Oribi
+Project-URL: Issues, https://github.com/samhoon000/Oribi/issues
+Keywords: pandas,data-profiling,data-analysis,data-quality,analytics
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+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 :: Scientific/Engineering :: Information Analysis
+Requires-Python: <3.15,>=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas<4,>=1.5.3
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: pytest-cov>=6; extra == "dev"
+Requires-Dist: build>=1.2; extra == "dev"
+Dynamic: license-file
+
+# Oribi
+
+Oribi profiles a pandas DataFrame and returns a structured, evidence-backed snapshot of its shape, column statistics, likely semantic roles, candidate keys, possible grain, relationships, and analytical warnings. Use it to inspect data before writing an analysis or to give downstream tools a compact description of a dataset.
+
+## Install
+
+```bash
+python -m pip install oribi
+```
+
+Oribi supports Python 3.10–3.14 and pandas 1.5.3 or newer (below pandas 4).
+
+## Quick start
+
+```python
+import pandas as pd
+from oribi import inspect
+
+df = pd.DataFrame({
+    "order_id": [101, 101, 102, 102],
+    "product_id": [7, 8, 7, 8],
+    "revenue": [25.0, 40.0, 30.0, -5.0],
+})
+
+context = inspect(df)
+print(context.summary())
+print(context.to_context(max_chars=2_000))
+```
+
+`inspect()` does not modify the DataFrame or keep a reference to it in the result. The returned snapshot can also be rendered as a full Markdown report or serialized to JSON-compatible data:
+
+```python
+markdown = context.to_markdown()
+payload = context.to_dict()
+json_text = context.to_json()
+```
+
+## What Oribi currently reports
+
+- Dataset row/column counts and duplicate rows.
+- Per-column missingness, distinct counts, numeric summaries, categorical top values, and datetime bounds.
+- Likely roles such as identifier, measure, dimension, categorical, temporal, boolean, text, or unknown, with evidence.
+- Candidate single-column and bounded two-column keys, plus a separate likely-grain estimate.
+- Conservative within-DataFrame functional-dependency relationships.
+- Recommendations for likely numeric measures and identifier counts.
+- Warnings for duplicate rows, missingness, non-unique identifiers, negative or skewed measures, high-cardinality categories, and possible gaps in regular datetime series.
+
+Inferences are heuristics, not guarantees about business meaning. Temporal-gap warnings require a sufficiently long series with a dominant fixed cadence; irregular event timestamps and short series are left without a gap claim. Relationships describe observed value mappings within one frame and do not prove that a join is valid or safe.
+
+## Public API
+
+The main operation is `oribi.inspect(df, *, options=None)`. It returns a `DatasetContext` snapshot. `ProfileOptions` can bound top values and exact key/quantile analysis:
+
+```python
+import pandas as pd
+from oribi import ProfileOptions, inspect
+
+df = pd.DataFrame({"amount": [12.5, 18.0, 20.0]})
+context = inspect(df, options=ProfileOptions(top_k=5, max_exact_rows=50_000))
+```
+
+Options include `top_k`, `include_quantiles`, `max_exact_rows`, and `max_key_columns`. Column labels must be unique strings. Datetime-like text is not parsed automatically. Profiling is in-memory and may require several full-column scans; exact composite-key checks are bounded by the configured row and column limits.
+
+Confidence values describe heuristic strength; they are not calibrated probabilities. A candidate key is evidence of observed uniqueness under the profiling rules, not proof of a business key. Serialized output includes `schema_version`; treat changes to that output as version-sensitive until a stable compatibility policy is declared.
+
+## Development
+
+```bash
+git clone https://github.com/samhoon000/Oribi.git
+cd Oribi
+python -m venv .venv
+```
+
+Activate the environment, then install the package and development tools:
+
+```bash
+python -m pip install -e ".[dev]"
+pytest -q
+python -m build
+```
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for the contribution workflow and [DESIGN.md](DESIGN.md) for architecture notes. Run the end-to-end example from the repository root with `python -m examples.quickstart`.
+
+## Planned work
+
+Additional data sources, configurable semantic rules, cross-table foreign-key analysis, and richer profiling options are future work. The current release focuses on pandas DataFrames and deterministic, evidence-bearing heuristics.
+
+## License
+
+Oribi is released under the [MIT License](LICENSE).

oribi-0.1.0/README.md

@@ -0,0 +1,90 @@
+# Oribi
+
+Oribi profiles a pandas DataFrame and returns a structured, evidence-backed snapshot of its shape, column statistics, likely semantic roles, candidate keys, possible grain, relationships, and analytical warnings. Use it to inspect data before writing an analysis or to give downstream tools a compact description of a dataset.
+
+## Install
+
+```bash
+python -m pip install oribi
+```
+
+Oribi supports Python 3.10–3.14 and pandas 1.5.3 or newer (below pandas 4).
+
+## Quick start
+
+```python
+import pandas as pd
+from oribi import inspect
+
+df = pd.DataFrame({
+    "order_id": [101, 101, 102, 102],
+    "product_id": [7, 8, 7, 8],
+    "revenue": [25.0, 40.0, 30.0, -5.0],
+})
+
+context = inspect(df)
+print(context.summary())
+print(context.to_context(max_chars=2_000))
+```
+
+`inspect()` does not modify the DataFrame or keep a reference to it in the result. The returned snapshot can also be rendered as a full Markdown report or serialized to JSON-compatible data:
+
+```python
+markdown = context.to_markdown()
+payload = context.to_dict()
+json_text = context.to_json()
+```
+
+## What Oribi currently reports
+
+- Dataset row/column counts and duplicate rows.
+- Per-column missingness, distinct counts, numeric summaries, categorical top values, and datetime bounds.
+- Likely roles such as identifier, measure, dimension, categorical, temporal, boolean, text, or unknown, with evidence.
+- Candidate single-column and bounded two-column keys, plus a separate likely-grain estimate.
+- Conservative within-DataFrame functional-dependency relationships.
+- Recommendations for likely numeric measures and identifier counts.
+- Warnings for duplicate rows, missingness, non-unique identifiers, negative or skewed measures, high-cardinality categories, and possible gaps in regular datetime series.
+
+Inferences are heuristics, not guarantees about business meaning. Temporal-gap warnings require a sufficiently long series with a dominant fixed cadence; irregular event timestamps and short series are left without a gap claim. Relationships describe observed value mappings within one frame and do not prove that a join is valid or safe.
+
+## Public API
+
+The main operation is `oribi.inspect(df, *, options=None)`. It returns a `DatasetContext` snapshot. `ProfileOptions` can bound top values and exact key/quantile analysis:
+
+```python
+import pandas as pd
+from oribi import ProfileOptions, inspect
+
+df = pd.DataFrame({"amount": [12.5, 18.0, 20.0]})
+context = inspect(df, options=ProfileOptions(top_k=5, max_exact_rows=50_000))
+```
+
+Options include `top_k`, `include_quantiles`, `max_exact_rows`, and `max_key_columns`. Column labels must be unique strings. Datetime-like text is not parsed automatically. Profiling is in-memory and may require several full-column scans; exact composite-key checks are bounded by the configured row and column limits.
+
+Confidence values describe heuristic strength; they are not calibrated probabilities. A candidate key is evidence of observed uniqueness under the profiling rules, not proof of a business key. Serialized output includes `schema_version`; treat changes to that output as version-sensitive until a stable compatibility policy is declared.
+
+## Development
+
+```bash
+git clone https://github.com/samhoon000/Oribi.git
+cd Oribi
+python -m venv .venv
+```
+
+Activate the environment, then install the package and development tools:
+
+```bash
+python -m pip install -e ".[dev]"
+pytest -q
+python -m build
+```
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for the contribution workflow and [DESIGN.md](DESIGN.md) for architecture notes. Run the end-to-end example from the repository root with `python -m examples.quickstart`.
+
+## Planned work
+
+Additional data sources, configurable semantic rules, cross-table foreign-key analysis, and richer profiling options are future work. The current release focuses on pandas DataFrames and deterministic, evidence-bearing heuristics.
+
+## License
+
+Oribi is released under the [MIT License](LICENSE).

oribi-0.1.0/examples/quickstart.py

@@ -0,0 +1,21 @@
+"""Runnable Oribi example: profile a small order-items DataFrame."""
+
+import pandas as pd
+
+from oribi import inspect
+
+
+orders = pd.DataFrame(
+    {
+        "order_id": [101, 101, 102, 102],
+        "product_id": [7, 8, 7, 8],
+        "revenue": [25.0, 40.0, 30.0, -5.0],
+        "order_date": pd.to_datetime(
+            ["2026-01-01", "2026-01-01", "2026-01-02", "2026-01-02"]
+        ),
+    }
+)
+
+context = inspect(orders)
+print(context.summary())
+print(context.to_context(max_chars=2_000))

oribi-0.1.0/oribi/__init__.py

@@ -0,0 +1,24 @@
+"""Build structured analytical context from pandas DataFrames."""
+
+from .api import ProfileOptions, inspect
+from .exceptions import InvalidInputError, OribiError
+from .models import (
+    ColumnContext,
+    DatasetContext,
+    Evidence,
+    GrainContext,
+    KeyCandidate,
+    Recommendation,
+    RelationshipContext,
+    SemanticContext,
+    StatisticsContext,
+    Warning,
+)
+
+__all__ = [
+    "ColumnContext", "DatasetContext", "Evidence", "GrainContext", "InvalidInputError",
+    "KeyCandidate", "ProfileOptions", "Recommendation", "RelationshipContext",
+    "OribiError", "SemanticContext", "StatisticsContext", "Warning", "inspect",
+]
+
+__version__ = "0.1.0"

oribi-0.1.0/oribi/api.py

@@ -0,0 +1,84 @@
+"""Public inspection API and pipeline orchestration."""
+
+from dataclasses import dataclass
+
+import pandas as pd
+
+from .exceptions import InvalidInputError
+from .models.context import ColumnContext, DatasetContext
+from .models.evidence import Warning
+from .models.profile import DatasetProfile
+from .profiling.columns import profile_column
+from .profiling.observations import AnalysisSession
+from .profiling.relationships import detect_relationships
+from .profiling.temporal import temporal_gap_warnings
+from .reasoning.keys import detect_keys
+from .reasoning.rules import dataset_warnings, reason_column
+from .reasoning.semantic import infer_semantic
+
+
+@dataclass(frozen=True)
+class ProfileOptions:
+    """Controls profiling work while keeping results deterministic."""
+
+    top_k: int = 10
+    include_quantiles: bool = True
+    max_exact_rows: int = 100_000
+    max_key_columns: int = 8
+
+    def __post_init__(self) -> None:
+        if self.top_k < 1:
+            raise ValueError("top_k must be at least 1")
+        if self.max_exact_rows < 1 or self.max_key_columns < 2:
+            raise ValueError("max_exact_rows must be positive and max_key_columns at least 2")
+
+
+def inspect(df: pd.DataFrame, *, options: ProfileOptions | None = None) -> DatasetContext:
+    """Profile a pandas DataFrame and return its analytical context snapshot.
+
+    The returned context contains no reference to ``df``. Object columns that
+    appear datetime-like are not parsed automatically.
+    """
+    options = options or ProfileOptions()
+    if not isinstance(options, ProfileOptions):
+        raise InvalidInputError("options must be a ProfileOptions instance")
+    session = AnalysisSession(df, options)
+    nrows, ncols = df.shape
+    try:
+        duplicates = int(df.duplicated().sum())
+    except (TypeError, ValueError):
+        duplicates = None
+    duplicate_rate = (duplicates / nrows) if duplicates is not None and nrows else (0.0 if duplicates == 0 else None)
+    names = list(df.columns)
+    observations = {name: session.observe(name) for name in names}
+    stats = {name: profile_column(obs, nrows, options.top_k, options.include_quantiles and nrows <= options.max_exact_rows) for name, obs in observations.items()}
+    semantics = {name: infer_semantic(name, observations[name].logical_type, stats[name], nrows) for name in names}
+    key_candidates, grain = detect_keys(
+        df, names, stats, {name: semantics[name].role for name in names},
+        max_columns=options.max_key_columns, max_exact_rows=options.max_exact_rows,
+    )
+    role_map = {name: semantics[name].role for name in names}
+    relationships = detect_relationships(df, role_map, max_rows=options.max_exact_rows)
+    columns = []
+    for name in names:
+        obs = observations[name]
+        recommendations, warnings = reason_column(name, obs.logical_type, semantics[name], stats[name])
+        if obs.logical_type == "temporal":
+            warnings += temporal_gap_warnings(obs.series, name)
+        columns.append(ColumnContext(name, str(obs.series.dtype), obs.logical_type, stats[name], semantics[name], recommendations, warnings))
+    global_warnings = list(dataset_warnings(duplicates, nrows))
+    for col in columns:
+        global_warnings.extend(col.warnings)
+    if duplicates is None:
+        global_warnings.append(Warning(
+            "duplicate_check_unavailable", "low", "Duplicate-row check unavailable",
+            "Pandas could not compare rows with the available cell values.",
+        ))
+    return DatasetContext(
+        profile=DatasetProfile(nrows, ncols, duplicates, duplicate_rate),
+        columns=tuple(columns),
+        candidate_keys=key_candidates,
+        grain=grain,
+        relationships=relationships,
+        warnings=tuple(global_warnings),
+    )

oribi-0.1.0/oribi/exceptions.py

@@ -0,0 +1,9 @@
+"""Public exceptions raised by Oribi."""
+
+
+class OribiError(Exception):
+    """Base exception for Oribi errors."""
+
+
+class InvalidInputError(OribiError, ValueError):
+    """Raised when an input cannot be profiled safely."""

oribi-0.1.0/oribi/models/__init__.py

@@ -0,0 +1,7 @@
+"""Public context models."""
+
+from .context import ColumnContext, DatasetContext
+from .evidence import Evidence, GrainContext, KeyCandidate, Recommendation, RelationshipContext, SemanticContext, Warning
+from .profile import StatisticsContext
+
+__all__ = ["ColumnContext", "DatasetContext", "Evidence", "GrainContext", "KeyCandidate", "Recommendation", "RelationshipContext", "SemanticContext", "StatisticsContext", "Warning"]

oribi-0.1.0/oribi/models/context.py

@@ -0,0 +1,59 @@
+"""Canonical result returned by :func:`oribi.inspect`."""
+
+from dataclasses import dataclass
+from typing import Any
+
+from .evidence import GrainContext, KeyCandidate, Recommendation, RelationshipContext, SemanticContext, Warning
+from .profile import DatasetProfile, StatisticsContext
+
+
+@dataclass(frozen=True)
+class ColumnContext:
+    name: str
+    dtype: str
+    logical_type: str
+    statistics: StatisticsContext
+    semantic: SemanticContext
+    recommendations: tuple[Recommendation, ...] = ()
+    warnings: tuple[Warning, ...] = ()
+
+
+@dataclass(frozen=True)
+class DatasetContext:
+    profile: DatasetProfile
+    columns: tuple[ColumnContext, ...]
+    candidate_keys: tuple[KeyCandidate, ...] = ()
+    grain: GrainContext | None = None
+    relationships: tuple[RelationshipContext, ...] = ()
+    warnings: tuple[Warning, ...] = ()
+    schema_version: str = "1"
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..serialization.dict import to_dict
+        return to_dict(self)
+
+    def to_json(self, *, indent: int | None = 2) -> str:
+        from ..serialization.dict import to_json
+        return to_json(self, indent=indent)
+
+    def to_markdown(self) -> str:
+        from ..serialization.markdown import to_markdown
+        return to_markdown(self)
+
+    def to_context(self, *, max_chars: int = 8000) -> str:
+        from ..serialization.context import to_context
+        return to_context(self, max_chars=max_chars)
+
+    def summary(self) -> str:
+        rows = self.profile.row_count
+        cols = self.profile.column_count
+        parts = [f"Dataset: {rows:,} rows × {cols:,} columns."]
+        if self.profile.duplicate_row_count:
+            parts.append(f"{self.profile.duplicate_row_count:,} duplicate rows observed.")
+        if self.grain and self.grain.status == "estimated" and self.grain.label:
+            parts.append(f"Likely grain: {self.grain.label} (confidence {self.grain.confidence:.2f}).")
+        elif self.grain:
+            parts.append("Likely grain could not be determined confidently.")
+        if self.warnings:
+            parts.append(f"{len(self.warnings)} analytical warning(s) detected.")
+        return " ".join(parts)

oribi-0.1.0/oribi/models/evidence.py

@@ -0,0 +1,80 @@
+"""Evidence-bearing inferences and recommendations."""
+
+from dataclasses import dataclass, field
+from collections.abc import Mapping
+from types import MappingProxyType
+from typing import Any
+
+
+def _freeze(value: Any) -> Any:
+    if isinstance(value, Mapping):
+        return MappingProxyType({key: _freeze(item) for key, item in value.items()})
+    if isinstance(value, (list, tuple)):
+        return tuple(_freeze(item) for item in value)
+    if isinstance(value, set):
+        return frozenset(_freeze(item) for item in value)
+    return value
+
+
+@dataclass(frozen=True)
+class Evidence:
+    code: str
+    statement: str
+    details: Mapping[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "details", _freeze(self.details))
+
+
+@dataclass(frozen=True)
+class SemanticContext:
+    role: str
+    confidence: float
+    evidence: tuple[Evidence, ...] = ()
+
+
+@dataclass(frozen=True)
+class Recommendation:
+    operation: str
+    disposition: str
+    rationale: str
+    evidence: tuple[Evidence, ...] = ()
+
+
+@dataclass(frozen=True)
+class Warning:
+    code: str
+    severity: str
+    title: str
+    message: str
+    evidence: tuple[Evidence, ...] = ()
+    implication: str = ""
+    recommendation: str | None = None
+
+
+@dataclass(frozen=True)
+class KeyCandidate:
+    columns: tuple[str, ...]
+    kind: str
+    confidence: float
+    uniqueness_rate: float
+    evidence: tuple[Evidence, ...] = ()
+
+
+@dataclass(frozen=True)
+class GrainContext:
+    status: str
+    label: str | None
+    columns: tuple[str, ...]
+    confidence: float
+    evidence: tuple[Evidence, ...] = ()
+
+
+@dataclass(frozen=True)
+class RelationshipContext:
+    source_column: str
+    target_column: str
+    kind: str
+    coverage: float
+    confidence: float
+    evidence: tuple[Evidence, ...] = ()

oribi-0.1.0/oribi/models/profile.py

@@ -0,0 +1,36 @@
+"""Observed dataset and column statistics."""
+
+from dataclasses import dataclass, field
+from collections.abc import Mapping
+from types import MappingProxyType
+from typing import Any
+
+
+@dataclass(frozen=True)
+class StatisticsContext:
+    missing_count: int
+    missing_rate: float
+    distinct_count: int
+    distinct_rate: float
+    minimum: Any = None
+    maximum: Any = None
+    mean: float | None = None
+    median: float | None = None
+    standard_deviation: float | None = None
+    quantiles: Mapping[str, float] = field(default_factory=dict)
+    zero_count: int | None = None
+    negative_count: int | None = None
+    skewness: float | None = None
+    top_values: tuple[tuple[Any, int], ...] = ()
+    date_range: str | None = None
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "quantiles", MappingProxyType(dict(self.quantiles)))
+
+
+@dataclass(frozen=True)
+class DatasetProfile:
+    row_count: int
+    column_count: int
+    duplicate_row_count: int | None
+    duplicate_row_rate: float | None

oribi-0.1.0/oribi/profiling/__init__.py

@@ -0,0 +1 @@
+"""Internal profiling components."""

oribi-0.1.0/oribi/profiling/columns.py

@@ -0,0 +1,49 @@
+"""Statistics for observed columns."""
+
+import math
+from typing import Any
+
+import pandas as pd
+
+from ..models.profile import StatisticsContext
+from .observations import ColumnObservation
+
+
+def profile_column(obs: ColumnObservation, row_count: int, top_k: int, include_quantiles: bool) -> StatisticsContext:
+    s = obs.series
+    denom = row_count or 1
+    non_null = s.dropna()
+    values: dict[str, Any] = {}
+    if obs.logical_type == "numeric" and len(non_null):
+        numeric = pd.to_numeric(non_null, errors="coerce").dropna()
+        if len(numeric):
+            def finite_or_none(value: Any) -> float | None:
+                result = float(value)
+                return result if math.isfinite(result) else None
+
+            values.update(minimum=numeric.min(), maximum=numeric.max(), mean=finite_or_none(numeric.mean()), median=finite_or_none(numeric.median()), standard_deviation=finite_or_none(numeric.std()))
+            values["zero_count"] = int((numeric == 0).sum())
+            values["negative_count"] = int((numeric < 0).sum())
+            if include_quantiles:
+                qs = numeric.quantile([.25, .5, .75])
+                values["quantiles"] = {str(q): float(v) for q, v in qs.items()}
+            if len(numeric) >= 3 and numeric.nunique() > 1:
+                skew = float(numeric.skew())
+                values["skewness"] = skew if pd.notna(skew) else None
+    elif obs.logical_type == "temporal" and len(non_null):
+        values["minimum"] = non_null.min()
+        values["maximum"] = non_null.max()
+        values["date_range"] = f"{values['minimum']} to {values['maximum']}"
+    if len(non_null) and (obs.logical_type in {"text", "categorical", "boolean", "unknown"} or obs.distinct_count <= top_k * 4):
+        try:
+            counts = non_null.value_counts(dropna=True).head(top_k)
+            values["top_values"] = tuple((k, int(v)) for k, v in counts.items())
+        except (TypeError, ValueError):
+            pass
+    return StatisticsContext(
+        missing_count=obs.missing_count,
+        missing_rate=obs.missing_count / denom,
+        distinct_count=obs.distinct_count,
+        distinct_rate=obs.distinct_count / denom,
+        **values,
+    )