oribi 0.1.0__py3-none-any.whl

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/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/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/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/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/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/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/profiling/__init__.py

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

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,
+    )

oribi/profiling/observations.py

@@ -0,0 +1,66 @@
+"""Per-call memoized observations shared across detectors."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+from typing import Any
+
+import pandas as pd
+
+from ..exceptions import InvalidInputError
+
+if TYPE_CHECKING:
+    from ..api import ProfileOptions
+
+
+@dataclass
+class ColumnObservation:
+    name: str
+    series: pd.Series
+    missing_count: int
+    distinct_count: int
+    logical_type: str
+    stats: dict[str, Any] = field(default_factory=dict)
+
+
+class AnalysisSession:
+    def __init__(self, frame: pd.DataFrame, options: ProfileOptions):
+        if not isinstance(frame, pd.DataFrame):
+            raise InvalidInputError("inspect() expects a pandas DataFrame")
+        if not frame.columns.is_unique:
+            raise InvalidInputError("DataFrame column labels must be unique")
+        if any(not isinstance(c, str) for c in frame.columns):
+            raise InvalidInputError("DataFrame column labels must be strings")
+        self.frame = frame
+        self.options = options
+        self.observations: dict[Any, ColumnObservation] = {}
+
+    def observe(self, name: Any) -> ColumnObservation:
+        if name in self.observations:
+            return self.observations[name]
+        series = self.frame[name]
+        missing = int(series.isna().sum())
+        try:
+            distinct = int(series.nunique(dropna=True))
+        except (TypeError, ValueError):
+            distinct = int(series.dropna().astype(str).nunique())
+        if pd.api.types.is_bool_dtype(series.dtype):
+            logical = "boolean"
+        elif pd.api.types.is_datetime64_any_dtype(series.dtype):
+            logical = "temporal"
+        elif pd.api.types.is_numeric_dtype(series.dtype):
+            logical = "numeric"
+        elif isinstance(series.dtype, pd.CategoricalDtype):
+            logical = "categorical"
+        elif series.dtype == object or pd.api.types.is_string_dtype(series.dtype):
+            values = series.dropna()
+            kinds = {type(v) for v in values.iloc[:100]}
+            logical = "unknown" if len(kinds) > 1 and len({"str" if issubclass(t, str) else t.__name__ for t in kinds}) > 1 else "text"
+            if values.empty:
+                logical = "unknown"
+        else:
+            logical = "unknown"
+        obs = ColumnObservation(str(name), series, missing, distinct, logical)
+        self.observations[name] = obs
+        return obs

oribi/profiling/relationships.py

@@ -0,0 +1,39 @@
+"""Conservative within-frame column dependency detection."""
+
+import pandas as pd
+
+from ..models.evidence import Evidence, RelationshipContext
+
+
+def detect_relationships(frame: pd.DataFrame, roles: dict[str, str], max_rows: int = 100_000) -> tuple[RelationshipContext, ...]:
+    """Find near-complete one-to-one value mappings among low-cardinality columns."""
+    if len(frame) == 0 or len(frame) > max_rows:
+        return ()
+    eligible = [name for name, role in roles.items() if role in {"identifier", "dimension", "categorical"}]
+    eligible = [name for name in eligible if frame[name].nunique(dropna=True) <= min(500, max(20, len(frame) // 2))]
+    results: list[RelationshipContext] = []
+    for source in eligible:
+        for target in eligible:
+            if source == target:
+                continue
+            pairs = frame[[source, target]].dropna().drop_duplicates()
+            source_values = frame[source].dropna().nunique()
+            if source_values < 2:
+                continue
+            unique_mapping = int(pairs.groupby(source, dropna=True)[target].nunique().le(1).sum())
+            coverage = unique_mapping / source_values
+            target_values = frame[target].dropna().nunique()
+            if coverage >= .98 and target_values > 1 and source_values <= target_values:
+                results.append(RelationshipContext(
+                    source, target, "functional_dependency", coverage,
+                    round(min(.95, .65 + coverage * .3), 2),
+                    (Evidence("value_mapping", f"{coverage:.1%} of observed {source} values map to one {target} value", {"source_distinct": int(source_values), "target_distinct": int(target_values), "coverage": coverage}),),
+                ))
+    # Keep only one orientation per pair to avoid duplicate, reversed claims.
+    deduped: dict[frozenset[str], RelationshipContext] = {}
+    for relation in results:
+        key = frozenset((relation.source_column, relation.target_column))
+        current = deduped.get(key)
+        if current is None or relation.source_column < current.source_column:
+            deduped[key] = relation
+    return tuple(sorted(deduped.values(), key=lambda r: (r.source_column, r.target_column)))

oribi/profiling/temporal.py

@@ -0,0 +1,75 @@
+"""Conservative temporal cadence and gap observations."""
+
+from collections import Counter
+
+import pandas as pd
+
+from ..models.evidence import Evidence, Warning
+
+_MIN_UNIQUE_TIMESTAMPS = 4
+_MIN_CADENCE_INTERVALS = 2
+_MIN_CADENCE_SHARE = 0.6
+
+
+def temporal_gap_warnings(series: pd.Series, column_name: str) -> tuple[Warning, ...]:
+    """Report possible gaps only when a dominant fixed cadence is supported."""
+    timestamps = pd.DatetimeIndex(series.dropna().drop_duplicates().sort_values())
+    if len(timestamps) < _MIN_UNIQUE_TIMESTAMPS:
+        return ()
+
+    deltas = [timestamps[i] - timestamps[i - 1] for i in range(1, len(timestamps))]
+    ranked = Counter(deltas).most_common()
+    cadence, dominant_count = ranked[0]
+    if len(ranked) > 1 and ranked[1][1] == dominant_count:
+        return ()
+    if dominant_count < _MIN_CADENCE_INTERVALS or dominant_count / len(deltas) < _MIN_CADENCE_SHARE:
+        return ()
+
+    steps_by_interval: list[int] = []
+    for delta in deltas:
+        steps = delta / cadence
+        if steps < 1 or steps != int(steps):
+            return ()
+        steps_by_interval.append(int(steps))
+    if not any(steps > 1 for steps in steps_by_interval):
+        return ()
+
+    cadence_text = _format_timedelta(cadence)
+    warnings: list[Warning] = []
+    for index, steps in enumerate(steps_by_interval):
+        missing_count = steps - 1
+        if not missing_count:
+            continue
+        before, after = timestamps[index], timestamps[index + 1]
+        expected = [before + cadence * step for step in range(1, steps)]
+        evidence = Evidence(
+            "temporal_gap",
+            f"{missing_count} timestamp(s) may be absent relative to an inferred {cadence_text} cadence",
+            {
+                "cadence": cadence_text,
+                "gap_start": expected[0].isoformat(),
+                "gap_end": expected[-1].isoformat(),
+                "missing_intervals": missing_count,
+                "expected_timestamps": [value.isoformat() for value in expected],
+                "observed_before": before.isoformat(),
+                "observed_after": after.isoformat(),
+            },
+        )
+        warnings.append(Warning(
+            "potential_temporal_gap", "low", "Potential temporal gap",
+            f"{column_name} has a possible temporal gap relative to an inferred {cadence_text} cadence.",
+            (evidence,),
+            "The interval may reflect missing observations or a normal pause in data collection.",
+            "Confirm the expected sampling schedule before treating the interval as missing data.",
+        ))
+    return tuple(warnings)
+
+
+def _format_timedelta(value: pd.Timedelta) -> str:
+    """Format common fixed cadence durations consistently."""
+    seconds = value.total_seconds()
+    for size, unit in ((86400, "day"), (3600, "hour"), (60, "minute"), (1, "second")):
+        if seconds % size == 0:
+            amount = int(seconds / size)
+            return f"{amount} {unit}{'' if amount == 1 else 's'}"
+    return str(value)

oribi/reasoning/__init__.py

@@ -0,0 +1 @@
+"""Deterministic analytical reasoning."""

oribi/reasoning/keys.py

@@ -0,0 +1,169 @@
+"""Candidate-key collection and separate grain selection."""
+
+from itertools import combinations
+import re
+
+import pandas as pd
+
+from ..models.evidence import Evidence, GrainContext, KeyCandidate
+
+_MIN_SINGLE_UNIQUENESS = 0.98
+_MAX_SINGLE_MISSING_RATE = 0.02
+_MIN_COMPOSITE_UNIQUENESS = 0.95
+_COMPOSITE_ROLES = {"identifier", "dimension", "categorical", "boolean"}
+
+
+def detect_candidate_keys(
+    frame: pd.DataFrame,
+    names: list[str],
+    stats: dict[str, object],
+    roles: dict[str, str],
+    max_columns: int = 8,
+    max_exact_rows: int = 100_000,
+) -> tuple[KeyCandidate, ...]:
+    """Collect qualifying single and bounded pair candidates.
+
+    Pair search considers at most ``max_columns`` non-unique identifier or
+    dimension-like columns (28 pairs at the default limit of eight), and only
+    runs below ``max_exact_rows``. This bounds exact combination scans while
+    allowing all qualifying candidates in the searched set to be retained.
+    """
+    row_count = len(frame)
+    if row_count == 0:
+        return ()
+    sample_support = min(1.0, (row_count / 100) ** 0.5)
+
+    single_candidates: list[KeyCandidate] = []
+    for name in sorted(names):
+        column_stats = stats[name]
+        rate = column_stats.distinct_count / row_count
+        if (
+            roles.get(name) == "identifier"
+            and rate >= _MIN_SINGLE_UNIQUENESS
+            and column_stats.missing_rate <= _MAX_SINGLE_MISSING_RATE
+        ):
+            evidence = Evidence(
+                "single_column_uniqueness",
+                f"{column_stats.distinct_count} distinct values across {row_count} rows",
+                {"distinct_count": column_stats.distinct_count, "row_count": row_count},
+            )
+            single_candidates.append(KeyCandidate(
+                (name,),
+                "single",
+                round(min(.95, .5 + (.6 + .4 * rate - .5) * sample_support), 2),
+                rate,
+                (evidence,),
+            ))
+
+    # A component already qualifying alone adds no useful composite candidate.
+    single_columns = {candidate.columns[0] for candidate in single_candidates}
+    potential = sorted(
+        (
+            name for name in names
+            if name not in single_columns
+            and _is_key_component(name, roles.get(name))
+            and stats[name].distinct_count > 1
+        ),
+        key=lambda name: (-stats[name].distinct_rate, stats[name].missing_rate, name),
+    )[:max_columns]
+
+    pair_candidates: list[KeyCandidate] = []
+    if row_count <= max_exact_rows:
+        for pair in combinations(potential, 2):
+            columns = tuple(sorted(pair))
+            try:
+                distinct_pairs = int(frame[list(columns)].drop_duplicates().shape[0])
+            except (TypeError, ValueError):
+                continue
+            rate = distinct_pairs / row_count
+            if rate >= _MIN_COMPOSITE_UNIQUENESS:
+                base_confidence = min(.9, .55 + (rate - _MIN_COMPOSITE_UNIQUENESS) * 5)
+                confidence = .5 + (base_confidence - .5) * sample_support
+                evidence = Evidence(
+                    "composite_uniqueness",
+                    f"{distinct_pairs} distinct pairs across {row_count} rows",
+                    {
+                        "distinct_pairs": distinct_pairs,
+                        "row_count": row_count,
+                        "uniqueness_rate": rate,
+                    },
+                )
+                pair_candidates.append(KeyCandidate(
+                    columns, "composite", round(confidence, 2), rate, (evidence,),
+                ))
+
+    # Candidate retention does not depend on this ordering. Simpler keys are
+    # listed first, with deterministic uniqueness/confidence/name tie-breakers.
+    return tuple(sorted(
+        (*single_candidates, *pair_candidates),
+        key=lambda candidate: (
+            len(candidate.columns),
+            -candidate.uniqueness_rate,
+            -candidate.confidence,
+            candidate.columns,
+        ),
+    ))
+
+
+def _is_key_component(name: str, role: str | None) -> bool:
+    """Allow established key-like name hints when role votes are ambiguous."""
+    if role in _COMPOSITE_ROLES:
+        return True
+    tokens = set(re.split(r"[^a-z0-9]+", name.lower()))
+    return "id" in tokens or name.lower().endswith(("_key", "_code"))
+
+
+def select_grain(candidates: tuple[KeyCandidate, ...]) -> GrainContext:
+    """Choose one preferred grain from the retained candidates."""
+    if not candidates:
+        return GrainContext("undetermined", None, (), 0.0, ())
+
+    # Preserve the existing preference for a single-column identifier when
+    # available; candidate detection still retains every composite candidate.
+    singles = [candidate for candidate in candidates if candidate.kind == "single"]
+    pool = singles or [candidate for candidate in candidates if candidate.kind == "composite"]
+    best = min(
+        pool,
+        key=lambda candidate: (
+            -candidate.uniqueness_rate,
+            -candidate.confidence,
+            candidate.columns,
+        ),
+    )
+    label = " × ".join(best.columns)
+    return GrainContext("estimated", label, best.columns, best.confidence, best.evidence)
+
+
+def detect_keys(
+    frame: pd.DataFrame,
+    names: list[str],
+    stats: dict[str, object],
+    roles: dict[str, str],
+    max_columns: int = 8,
+    max_exact_rows: int = 100_000,
+) -> tuple[tuple[KeyCandidate, ...], GrainContext]:
+    """Collect candidate keys, then independently select a grain hypothesis."""
+    candidates = detect_candidate_keys(
+        frame, names, stats, roles,
+        max_columns=max_columns,
+        max_exact_rows=max_exact_rows,
+    )
+    if len(frame) == 0:
+        grain = GrainContext(
+            "undetermined", None, (), 0.0,
+            (Evidence("empty_dataset", "No rows are available to estimate a key or grain"),),
+        )
+    elif candidates:
+        grain = select_grain(candidates)
+    else:
+        code = "key_search_bounded" if len(frame) > max_exact_rows else "no_strong_key"
+        message = (
+            "Composite key search was skipped because the DataFrame exceeds max_exact_rows"
+            if len(frame) > max_exact_rows
+            else "No single column or tested column pair was sufficiently unique"
+        )
+        grain = GrainContext(
+            "undetermined", None, (), 0.0,
+            (Evidence(code, message, {"row_count": len(frame), "max_exact_rows": max_exact_rows}),),
+        )
+    return candidates, grain

oribi/reasoning/rules.py

@@ -0,0 +1,30 @@
+"""Structured warnings and aggregation recommendations."""
+
+from ..models.evidence import Evidence, Recommendation, Warning
+
+
+def reason_column(name: str, logical_type: str, semantic: object, stats: object) -> tuple[tuple[Recommendation, ...], tuple[Warning, ...]]:
+    recommendations: list[Recommendation] = []
+    warnings: list[Warning] = []
+    if stats.missing_rate >= .2:
+        warnings.append(Warning("high_missingness", "medium", "High missingness", f"{name} is missing {stats.missing_rate:.1%} of its values.", (Evidence("missing_rate", f"{stats.missing_count} of values are missing", {"missing_count": stats.missing_count, "missing_rate": stats.missing_rate}),), "Analyses using this column may exclude many rows.", "Check whether missing values have a meaningful interpretation."))
+    if semantic.role == "identifier":
+        recommendations.append(Recommendation("COUNT DISTINCT", "recommended", "Distinct counting is more appropriate for counting entities than summing identifier values.", semantic.evidence))
+        if stats.distinct_rate < .98:
+            warnings.append(Warning("non_unique_identifier", "medium", "Identifier-like column is not unique", f"{name} has {stats.distinct_count} distinct values across rows and may identify repeated entities.", semantic.evidence, "Row counts may exceed entity counts.", "Use a distinct count when counting these entities."))
+    if semantic.role == "measure":
+        for op, disposition in (("SUM", "recommended"), ("MEAN", "recommended"), ("MEDIAN", "useful"), ("MIN", "valid"), ("MAX", "valid")):
+            recommendations.append(Recommendation(op, disposition, "The column is numeric and inferred as a likely measure.", semantic.evidence))
+        if stats.skewness is not None and abs(stats.skewness) >= 2:
+            warnings.append(Warning("high_skew", "low", "Highly skewed measure", f"{name} has skewness {stats.skewness:.2f}.", (Evidence("skewness", "Observed distribution is strongly skewed", {"skewness": stats.skewness}),), "The mean may be sensitive to a small number of large values.", "Consider reporting the median alongside the mean."))
+        if stats.negative_count:
+            warnings.append(Warning("negative_measure_values", "low", f"Negative values in {name}", f"{stats.negative_count} negative values were observed in likely measure {name}.", (Evidence("negative_count", f"{stats.negative_count} values are below zero", {"negative_count": stats.negative_count}),), "Negative values may represent refunds, reversals, or data issues.", "Check domain meaning before filtering negative values."))
+    if logical_type == "categorical" and stats.distinct_count > 100:
+        warnings.append(Warning("high_cardinality_category", "low", "High-cardinality category", f"{name} has {stats.distinct_count} distinct categories.", (), "Grouping by this column may produce many small groups."))
+    return tuple(recommendations), tuple(warnings)
+
+
+def dataset_warnings(duplicate_count: int | None, row_count: int) -> tuple[Warning, ...]:
+    if duplicate_count:
+        return (Warning("duplicate_rows", "medium", "Duplicate rows detected", f"{duplicate_count} fully duplicated rows were observed.", (Evidence("duplicate_count", f"{duplicate_count} duplicate rows across {row_count} total rows", {"duplicate_row_count": duplicate_count, "row_count": row_count}),), "Duplicates can inflate aggregates.", "Confirm whether repeated rows are expected before aggregation."),)
+    return ()

oribi/reasoning/semantic.py

@@ -0,0 +1,67 @@
+"""Composable rules for likely column roles."""
+
+import re
+
+from ..models.evidence import Evidence, SemanticContext
+
+
+_MEASURE_NAME_HINTS = ("amount", "price", "revenue", "sales", "quantity", "count", "total", "cost", "rate", "profit", "margin")
+_MIN_ROLE_SCORE = 0.55
+_AMBIGUITY_MARGIN = 0.12
+
+def infer_semantic(name: str, logical_type: str, stats: object, row_count: int) -> SemanticContext:
+    votes: dict[str, float] = {}
+    evidence: list[Evidence] = []
+    lname = name.lower()
+    distinct = stats.distinct_count
+    rate = stats.distinct_rate
+    tokens = set(re.split(r"[^a-z0-9]+", lname))
+    explicit_identifier_name = "id" in tokens or lname.endswith("_key")
+    code_name = lname.endswith("_code")
+    if explicit_identifier_name:
+        votes["identifier"] = .88
+        evidence.append(Evidence("name_identifier_hint", "Column name strongly suggests an identifier"))
+    elif code_name:
+        votes["identifier"] = .78
+        evidence.append(Evidence("name_identifier_hint", "Column name suggests an identifier"))
+    if row_count and rate >= .98 and distinct > 1:
+        # Uniqueness is supporting evidence, not proof of business identity.
+        # It is deliberately weaker for numeric columns, which commonly hold
+        # continuous measures that happen to be unique in small samples.
+        unique_vote = .28 if logical_type == "numeric" else .62
+        votes["identifier"] = max(votes.get("identifier", 0), unique_vote)
+        evidence.append(Evidence("mostly_unique", f"{distinct} distinct non-null values across {row_count} rows", {"distinct_count": distinct, "row_count": row_count, "distinct_rate": rate}))
+    if logical_type == "numeric":
+        votes["measure"] = .48
+        evidence.append(Evidence("numeric_type", "Column has a numeric dtype"))
+        if any(w in tokens for w in _MEASURE_NAME_HINTS):
+            votes["measure"] += .28
+            evidence.append(Evidence("name_measure_hint", "Column name suggests a quantitative measure"))
+    elif logical_type == "temporal":
+        votes["temporal"] = .86
+        evidence.append(Evidence("datetime_dtype", "Column has a datetime dtype"))
+    elif logical_type == "boolean":
+        votes["boolean"] = .9
+        evidence.append(Evidence("boolean_dtype", "Column has a boolean dtype"))
+    elif logical_type == "categorical":
+        votes["categorical"] = .78
+        evidence.append(Evidence("categorical_dtype", "Column has a categorical dtype"))
+    elif logical_type == "text":
+        if rate > .5 and distinct > 20:
+            votes["text"] = .62
+            evidence.append(Evidence("high_cardinality_text", "Text values have relatively high cardinality"))
+        else:
+            votes["dimension"] = .62
+            evidence.append(Evidence("text_dimension", "Text values are reusable across rows"))
+    if logical_type == "numeric" and distinct <= min(20, max(3, row_count // 10)):
+        votes["dimension"] = max(votes.get("dimension", 0), .64)
+        evidence.append(Evidence("low_cardinality_numeric", "Numeric values have low cardinality"))
+    if not votes:
+        return SemanticContext("unknown", 0.0, tuple(evidence))
+    role, score = max(votes.items(), key=lambda item: (item[1], item[0]))
+    ranked_votes = sorted(votes.items(), key=lambda item: (-item[1], item[0]))
+    if score < _MIN_ROLE_SCORE:
+        return SemanticContext("unknown", round(score, 2), tuple(evidence))
+    if len(ranked_votes) > 1 and score - ranked_votes[1][1] < _AMBIGUITY_MARGIN:
+        return SemanticContext("unknown", round(min(score, .5), 2), tuple(evidence))
+    return SemanticContext(role, round(min(score, .98), 2), tuple(evidence))

oribi/serialization/__init__.py

@@ -0,0 +1 @@
+"""Pure renderers for DatasetContext."""

oribi/serialization/context.py

@@ -0,0 +1,51 @@
+"""Compact AI-oriented rendering of an existing context snapshot."""
+
+from typing import Any
+
+
+def to_context(context: Any, *, max_chars: int = 8000) -> str:
+    if max_chars < 100:
+        raise ValueError("max_chars must be at least 100")
+    p = context.profile
+    header = [f"DATASET (observed): {p.row_count} rows, {p.column_count} columns."]
+    if p.duplicate_row_count:
+        header.append(f"Duplicate rows (observed): {p.duplicate_row_count}.")
+    grain_lines = []
+    if context.grain:
+        if context.grain.status == "estimated":
+            grain_lines.append(f"Likely grain (inference, confidence {context.grain.confidence:.2f}): {context.grain.label}.")
+            grain_lines.extend(f"  Evidence: {e.statement}." for e in context.grain.evidence)
+        else:
+            grain_lines.append("Likely grain: undetermined from available evidence.")
+    warning_lines = ["WARNINGS"] if context.warnings else []
+    for warning in context.warnings:
+        warning_lines.append(f"- [{warning.severity}] {warning.message} {warning.implication}".strip())
+    column_lines = ["COLUMNS"]
+    ranked = sorted(context.columns, key=lambda c: (c.semantic.role not in {"identifier", "measure", "temporal"}, -len(c.warnings), c.name))
+    for col in ranked:
+        s = col.statistics
+        column_lines.append(f"- {col.name} [{col.dtype}]: likely {col.semantic.role} ({col.semantic.confidence:.2f}); observed {s.distinct_count} distinct, {s.missing_rate:.1%} missing.")
+        for e in col.semantic.evidence[:2]:
+            column_lines.append(f"  Evidence: {e.statement}.")
+        if s.minimum is not None or s.maximum is not None:
+            column_lines.append(f"  Observed range: {s.minimum} to {s.maximum}.")
+        for rec in col.recommendations:
+            if rec.disposition in {"recommended", "caution"}:
+                column_lines.append(f"  Suggested {rec.operation}: {rec.rationale}.")
+    if context.relationships:
+        column_lines.append("OBSERVED RELATIONSHIPS")
+        for rel in context.relationships:
+            column_lines.append(f"- {rel.source_column} -> {rel.target_column}: {rel.kind}, coverage {rel.coverage:.1%}.")
+    lines = header + grain_lines + warning_lines + column_lines
+    result = "\n".join(lines)
+    if len(result) <= max_chars:
+        return result
+    marker = "[Context truncated.]"
+    selected: list[str] = []
+    for line in header + grain_lines + warning_lines + column_lines:
+        candidate = "\n".join((*selected, line, marker))
+        if len(candidate) <= max_chars:
+            selected.append(line)
+    if not selected:
+        return marker[:max_chars]
+    return "\n".join((*selected, marker))

oribi/serialization/dict.py

@@ -0,0 +1,39 @@
+"""JSON-compatible projection of the canonical model."""
+
+import json
+import math
+from collections.abc import Mapping
+from dataclasses import fields, is_dataclass
+from datetime import date, datetime
+from typing import Any
+
+
+def _normalize(value: Any) -> Any:
+    if is_dataclass(value):
+        return {field.name: _normalize(getattr(value, field.name)) for field in fields(value)}
+    if isinstance(value, Mapping):
+        return {str(k): _normalize(v) for k, v in value.items()}
+    if isinstance(value, (tuple, list)):
+        return [_normalize(v) for v in value]
+    if isinstance(value, (datetime, date)):
+        return value.isoformat()
+    if hasattr(value, "item"):
+        try:
+            return _normalize(value.item())
+        except (ValueError, TypeError):
+            pass
+    if isinstance(value, float) and not math.isfinite(value):
+        return None
+    if value is None or isinstance(value, (str, int, float, bool)):
+        return value
+    return str(value)
+
+
+def to_dict(context: Any) -> dict[str, Any]:
+    """Return a stable, JSON-compatible representation."""
+    return _normalize(context)
+
+
+def to_json(context: Any, *, indent: int | None = 2) -> str:
+    """Serialize a context using the standard JSON encoder."""
+    return json.dumps(to_dict(context), indent=indent, sort_keys=True, ensure_ascii=False)

oribi/serialization/markdown.py

@@ -0,0 +1,36 @@
+"""Human-readable context report."""
+
+from typing import Any
+
+
+def to_markdown(context: Any) -> str:
+    profile = context.profile
+    lines = ["# Dataset context", "", f"- Rows: {profile.row_count:,}", f"- Columns: {profile.column_count:,}"]
+    if profile.duplicate_row_count is not None:
+        lines.append(f"- Duplicate rows: {profile.duplicate_row_count:,}")
+    lines += ["", "## Likely grain", ""]
+    if context.grain and context.grain.status == "estimated":
+        lines.append(f"{context.grain.label} (confidence {context.grain.confidence:.2f})")
+        lines.extend(f"- {e.statement}" for e in context.grain.evidence)
+    else:
+        lines.append("Undetermined")
+    lines += ["", "## Columns", ""]
+    for col in context.columns:
+        s = col.statistics
+        lines += [f"### {col.name}", f"- Type: {col.dtype} ({col.logical_type})", f"- Likely role: {col.semantic.role} ({col.semantic.confidence:.2f})", f"- Missing: {s.missing_count:,} ({s.missing_rate:.1%})", f"- Distinct: {s.distinct_count:,} ({s.distinct_rate:.1%})"]
+        if s.minimum is not None or s.maximum is not None:
+            lines.append(f"- Range: {s.minimum} to {s.maximum}")
+        for rec in col.recommendations:
+            lines.append(f"- {rec.disposition.title()}: {rec.operation} — {rec.rationale}")
+        for warning in col.warnings:
+            lines.append(f"- Warning [{warning.severity}]: {warning.message}")
+        lines.append("")
+    if context.warnings:
+        lines += ["## Analytical warnings", ""]
+        for warning in context.warnings:
+            lines.append(f"- **{warning.title}** ({warning.severity}): {warning.message}")
+            if warning.implication:
+                lines.append(f"  - Implication: {warning.implication}")
+            if warning.recommendation:
+                lines.append(f"  - Suggested: {warning.recommendation}")
+    return "\n".join(lines).strip()

oribi-0.1.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,25 @@
+oribi/__init__.py,sha256=es5tbOxceggHrVz8QVGeSyflcAJOnkKcTzdeWATZcKQ,662
+oribi/api.py,sha256=tVWjiEpV0yASJP0y3HH19UQB15XOnQA4c3hsmgXUHB0,3764
+oribi/exceptions.py,sha256=6Pi1lSbfQma9yEPa-mYYE5xjtuZQULNm-l1K6J71ODc,224
+oribi/models/__init__.py,sha256=46DaTjg-OnJUp7jq9ytSGI4vs1uusX7AYYaLnfCkGYc,425
+oribi/models/context.py,sha256=E6bmOTfhK6gfI3sTKk9k0NF0vHgFZW9LykgUQed--wA,2168
+oribi/models/evidence.py,sha256=Q8QwxzPy1LeYFi3hr6Z643l5oTgAewrZoFVTxrZoWtY,1816
+oribi/models/profile.py,sha256=TeU2fj0nhydNdZOjW79xfT96xxqZt7lF8HH8fFyFr0Q,1023
+oribi/profiling/__init__.py,sha256=nlxBHD5s-Vqs-BS_Oiw0VRGnqghG4GvYbdoWegyHGy4,37
+oribi/profiling/columns.py,sha256=uWEtIsIQJzja9EKFybZIew4pg_NsFo2ZIvRa0KqRnJM,2199
+oribi/profiling/observations.py,sha256=BFEzlhuG7T3VxBm4Mca4F0Wxz1cGG86_p1VZ2iedYdY,2432
+oribi/profiling/relationships.py,sha256=VrnqPBEcyN1LRfPkVHcl3-UP6zDjoREJ0ouoMXT4y7U,2220
+oribi/profiling/temporal.py,sha256=OgiZP9lXnAiN50XQWe-mHBErTcO0-dYqtPPqXP8OnY4,3028
+oribi/reasoning/__init__.py,sha256=ypyGZJECBGlzwBftcOxhpTIY4wcqZyywNQcMjOgmQ7I,42
+oribi/reasoning/keys.py,sha256=VZ3x0KYg0hw0Gr3CCJuDUp_JVhmf_uqZ5Spa0x4eirs,6498
+oribi/reasoning/rules.py,sha256=xvCKv4rGFNFT0mwB9tafE6nPAG5y-tsaZBR1HDv1s-s,3470
+oribi/reasoning/semantic.py,sha256=tyFrayTZPVELUSgkS4UepFa3zOS0D_nSnR8HmFysq0Y,3651
+oribi/serialization/__init__.py,sha256=cX3RUUt6PghDMtSjP2irG0TfT7ST7HggL5NO8qK_3H4,41
+oribi/serialization/context.py,sha256=U3dR2QfiF2Sh5DPwMYVQx2SQ85ey7zmkEZ2JKAHTpyA,2677
+oribi/serialization/dict.py,sha256=8RnIEd44U4YLQWEs22ROYTVrxla_WrLZq08qVZScVjY,1338
+oribi/serialization/markdown.py,sha256=4zpWsKBw6EZyOgehMNSDggd2AYaPNFxx8U8UcoDUfQ0,1907
+oribi-0.1.0.dist-info/licenses/LICENSE,sha256=YFnvQifh-Fdzfcy6NxNEQOWa2kCVQ6jLq6nW2YfUiQ4,1075
+oribi-0.1.0.dist-info/METADATA,sha256=9Q9UmgFkgWsBeKcdY8pWGZx1y0Lv5WnJ13_zFjDSTkY,5184
+oribi-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+oribi-0.1.0.dist-info/top_level.txt,sha256=5QKQlmM4Q0-TU5jVrQCI9V0xMcfrHV_RosRx6lVyt3I,6
+oribi-0.1.0.dist-info/RECORD,,

oribi-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

oribi-0.1.0.dist-info/licenses/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.dist-info/top_level.txt

@@ -0,0 +1 @@
+oribi