edasnap 0.1.0__tar.gz

edasnap-0.1.0/LICENSE

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

edasnap-0.1.0/PKG-INFO

@@ -0,0 +1,162 @@
+Metadata-Version: 2.4
+Name: edasnap
+Version: 0.1.0
+Summary: A fast, honest first look at any pandas DataFrame — one-liner EDA helpers, no bloat.
+Author: sivaraam.kr
+License: MIT
+Project-URL: Homepage, https://github.com/sivaraam-kr/edasnap
+Project-URL: Issues, https://github.com/sivaraam-kr/edasnap/issues
+Keywords: eda,exploratory-data-analysis,pandas,data-science,data-quality
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Education
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=1.3
+Requires-Dist: matplotlib>=3.4
+Requires-Dist: seaborn>=0.11
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: license-file
+
+# edasnap
+
+**A fast, honest first look at any pandas DataFrame — in one line each.**
+
+`edasnap` answers the questions you ask every single time you load a new
+dataset: What's the shape? What's null, and how much? What are my numeric
+vs. categorical columns? Are there duplicate rows, constant columns, or
+columns that are secretly IDs? Do `"USA"`, `"usa "`, and `"U.S.A"` need to
+be merged into one category? Will this merge silently blow up my row count?
+
+It's built to be the opposite of a giant auto-generated HTML report:
+
+- **One function, one job.** No monolithic `report()` that dumps 40 sections
+  you didn't ask for — call only what you need.
+- **Every function returns real data** (a `dict`, a `DataFrame`, a
+  matplotlib `Figure`) — never just a printout you can't reuse.
+- **Never mutates your DataFrame.** Everything is read-only analysis.
+- **Small on purpose.** Just pandas EDA — no bundled ML training, no
+  encoding pipelines, no computer vision, no LLM calls. It's a lens on your
+  data, not a pipeline.
+- **Doesn't crash on messy real data** — mixed types, weird strings, and
+  edge cases (empty df, all-null column, single row) are handled, not
+  fatal.
+- **Readable source.** Every function is short enough to read in ten
+  seconds if you're curious what it's actually doing — handy if you're
+  still learning pandas.
+
+## Install
+
+```bash
+pip install edasnap
+```
+
+## Quickstart
+
+```python
+import pandas as pd
+import edasnap as es
+
+df = pd.read_csv("data.csv")
+
+es.quick_report(df)   # runs the core checks below, in a sensible order
+```
+
+## All functions
+
+### Structure & column types
+
+| Function | What it tells you |
+|---|---|
+| `es.overview(df)` | Row/column count, total + per-column memory usage, duplicate row count |
+| `es.dtypes_report(df)` | Buckets every column into `numeric`, `categorical`, `datetime`, `boolean`, or `text` |
+| `es.get_numeric_cols(df)` | List of numeric column names — ready to hand to a plot or model |
+| `es.get_categorical_cols(df)` | List of categorical column names |
+| `es.get_datetime_cols(df)` | List of datetime column names |
+
+```python
+es.overview(df)
+# {'rows': 891, 'columns': 12, 'duplicate_rows': 0,
+#  'total_memory_mb': 0.29, 'memory_by_column_mb': {...}}
+
+es.dtypes_report(df)
+# {'numeric': ['Age', 'Fare'], 'categorical': ['Sex', 'Embarked'], ...}
+```
+
+### Data quality
+
+| Function | What it tells you |
+|---|---|
+| `es.nulls(df)` | % missing per column, worst first — only columns that actually have nulls |
+| `es.duplicates(df, subset=None)` | Duplicate row count, % of the dataset, and a preview |
+| `es.constant_and_id_cols(df)` | Columns with only one value (dead weight), and columns that are likely IDs (`nunique == len(df)`) — both are common "don't feed this to a model" traps |
+| `es.inconsistent_categories(df)` | Flags values in text columns that are probably the same category typed differently — `"USA"` / `"usa "` / `"U.S.A"` — a check the bigger EDA tools skip |
+| `es.outlier_report(df, method="iqr")` | Outlier count and % per numeric column, via IQR or z-score — as a table, no plot needed |
+
+```python
+es.nulls(df)
+#           null_count  null_pct
+# Cabin            687     77.10
+# Age               177     19.87
+
+es.inconsistent_categories(df)
+# {'country': {'usa': ['USA', 'usa ', 'U.S.A'], 'uk': ['UK', 'uk']}}
+```
+
+### Summary stats
+
+| Function | What it tells you |
+|---|---|
+| `es.describe_plus(df)` | `.describe()` plus null %, skew, kurtosis, and dtype in one table |
+| `es.unique_report(df)` | `nunique` + a few example values per column |
+
+### Plots (each returns the matplotlib `Figure`)
+
+| Function | What it draws |
+|---|---|
+| `es.plot_numeric_distributions(df)` | Histogram + boxplot grid, one pair per numeric column |
+| `es.plot_categorical_counts(df, top_n=10)` | Bar chart grid per categorical column, capped at the top N values |
+| `es.plot_correlation(df)` | Masked correlation heatmap over numeric columns |
+| `es.plot_target_relationship(df, target="price")` | Auto-picks boxplot/violin/scatter per feature against your target column |
+| `es.plot_missing(df)` | Heatmap of where nulls occur across the whole DataFrame |
+
+### Comparing two DataFrames
+
+| Function | What it tells you |
+|---|---|
+| `es.compare_dfs(train_df, test_df)` | Shared/added/removed columns and dtype mismatches between two DataFrames — e.g. train vs. test drift |
+| `es.check_merge_keys(orders_df, users_df, on="user_id")` | Before you `merge()`: dtype mismatch on the key, % of keys missing on each side, and duplicate-key counts on each side — the usual cause of a merge silently multiplying your row count |
+
+### The one convenience function
+
+| Function | What it does |
+|---|---|
+| `es.quick_report(df)` | Chains `overview` → `nulls` → `dtypes_report` → `duplicates` → `constant_and_id_cols` → a numeric-distribution plot, prints a readable summary, and returns everything as a dict. Every piece it calls also works standalone. |
+
+## Development
+
+```bash
+git clone https://github.com/sivaraam-kr/edasnap
+cd edasnap
+pip install -e ".[dev]"
+pytest
+```
+
+## Publishing
+
+See [PUBLISHING.md](PUBLISHING.md) for the release checklist.
+
+## License
+
+MIT

edasnap-0.1.0/README.md

@@ -0,0 +1,131 @@
+# edasnap
+
+**A fast, honest first look at any pandas DataFrame — in one line each.**
+
+`edasnap` answers the questions you ask every single time you load a new
+dataset: What's the shape? What's null, and how much? What are my numeric
+vs. categorical columns? Are there duplicate rows, constant columns, or
+columns that are secretly IDs? Do `"USA"`, `"usa "`, and `"U.S.A"` need to
+be merged into one category? Will this merge silently blow up my row count?
+
+It's built to be the opposite of a giant auto-generated HTML report:
+
+- **One function, one job.** No monolithic `report()` that dumps 40 sections
+  you didn't ask for — call only what you need.
+- **Every function returns real data** (a `dict`, a `DataFrame`, a
+  matplotlib `Figure`) — never just a printout you can't reuse.
+- **Never mutates your DataFrame.** Everything is read-only analysis.
+- **Small on purpose.** Just pandas EDA — no bundled ML training, no
+  encoding pipelines, no computer vision, no LLM calls. It's a lens on your
+  data, not a pipeline.
+- **Doesn't crash on messy real data** — mixed types, weird strings, and
+  edge cases (empty df, all-null column, single row) are handled, not
+  fatal.
+- **Readable source.** Every function is short enough to read in ten
+  seconds if you're curious what it's actually doing — handy if you're
+  still learning pandas.
+
+## Install
+
+```bash
+pip install edasnap
+```
+
+## Quickstart
+
+```python
+import pandas as pd
+import edasnap as es
+
+df = pd.read_csv("data.csv")
+
+es.quick_report(df)   # runs the core checks below, in a sensible order
+```
+
+## All functions
+
+### Structure & column types
+
+| Function | What it tells you |
+|---|---|
+| `es.overview(df)` | Row/column count, total + per-column memory usage, duplicate row count |
+| `es.dtypes_report(df)` | Buckets every column into `numeric`, `categorical`, `datetime`, `boolean`, or `text` |
+| `es.get_numeric_cols(df)` | List of numeric column names — ready to hand to a plot or model |
+| `es.get_categorical_cols(df)` | List of categorical column names |
+| `es.get_datetime_cols(df)` | List of datetime column names |
+
+```python
+es.overview(df)
+# {'rows': 891, 'columns': 12, 'duplicate_rows': 0,
+#  'total_memory_mb': 0.29, 'memory_by_column_mb': {...}}
+
+es.dtypes_report(df)
+# {'numeric': ['Age', 'Fare'], 'categorical': ['Sex', 'Embarked'], ...}
+```
+
+### Data quality
+
+| Function | What it tells you |
+|---|---|
+| `es.nulls(df)` | % missing per column, worst first — only columns that actually have nulls |
+| `es.duplicates(df, subset=None)` | Duplicate row count, % of the dataset, and a preview |
+| `es.constant_and_id_cols(df)` | Columns with only one value (dead weight), and columns that are likely IDs (`nunique == len(df)`) — both are common "don't feed this to a model" traps |
+| `es.inconsistent_categories(df)` | Flags values in text columns that are probably the same category typed differently — `"USA"` / `"usa "` / `"U.S.A"` — a check the bigger EDA tools skip |
+| `es.outlier_report(df, method="iqr")` | Outlier count and % per numeric column, via IQR or z-score — as a table, no plot needed |
+
+```python
+es.nulls(df)
+#           null_count  null_pct
+# Cabin            687     77.10
+# Age               177     19.87
+
+es.inconsistent_categories(df)
+# {'country': {'usa': ['USA', 'usa ', 'U.S.A'], 'uk': ['UK', 'uk']}}
+```
+
+### Summary stats
+
+| Function | What it tells you |
+|---|---|
+| `es.describe_plus(df)` | `.describe()` plus null %, skew, kurtosis, and dtype in one table |
+| `es.unique_report(df)` | `nunique` + a few example values per column |
+
+### Plots (each returns the matplotlib `Figure`)
+
+| Function | What it draws |
+|---|---|
+| `es.plot_numeric_distributions(df)` | Histogram + boxplot grid, one pair per numeric column |
+| `es.plot_categorical_counts(df, top_n=10)` | Bar chart grid per categorical column, capped at the top N values |
+| `es.plot_correlation(df)` | Masked correlation heatmap over numeric columns |
+| `es.plot_target_relationship(df, target="price")` | Auto-picks boxplot/violin/scatter per feature against your target column |
+| `es.plot_missing(df)` | Heatmap of where nulls occur across the whole DataFrame |
+
+### Comparing two DataFrames
+
+| Function | What it tells you |
+|---|---|
+| `es.compare_dfs(train_df, test_df)` | Shared/added/removed columns and dtype mismatches between two DataFrames — e.g. train vs. test drift |
+| `es.check_merge_keys(orders_df, users_df, on="user_id")` | Before you `merge()`: dtype mismatch on the key, % of keys missing on each side, and duplicate-key counts on each side — the usual cause of a merge silently multiplying your row count |
+
+### The one convenience function
+
+| Function | What it does |
+|---|---|
+| `es.quick_report(df)` | Chains `overview` → `nulls` → `dtypes_report` → `duplicates` → `constant_and_id_cols` → a numeric-distribution plot, prints a readable summary, and returns everything as a dict. Every piece it calls also works standalone. |
+
+## Development
+
+```bash
+git clone https://github.com/sivaraam-kr/edasnap
+cd edasnap
+pip install -e ".[dev]"
+pytest
+```
+
+## Publishing
+
+See [PUBLISHING.md](PUBLISHING.md) for the release checklist.
+
+## License
+
+MIT

edasnap-0.1.0/pyproject.toml

@@ -0,0 +1,46 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "edasnap"
+version = "0.1.0"
+description = "A fast, honest first look at any pandas DataFrame — one-liner EDA helpers, no bloat."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [
+    { name = "sivaraam.kr" }
+]
+keywords = ["eda", "exploratory-data-analysis", "pandas", "data-science", "data-quality"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "Intended Audience :: Education",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering",
+]
+dependencies = [
+    "pandas>=1.3",
+    "matplotlib>=3.4",
+    "seaborn>=0.11",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "build",
+    "twine",
+]
+
+[project.urls]
+Homepage = "https://github.com/sivaraam-kr/edasnap"
+Issues = "https://github.com/sivaraam-kr/edasnap/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]

edasnap-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

edasnap-0.1.0/src/edasnap/__init__.py

@@ -0,0 +1,51 @@
+"""edasnap: fast, simple, one-liner EDA helpers for pandas DataFrames."""
+
+from .overview import (
+    dtypes_report,
+    get_categorical_cols,
+    get_datetime_cols,
+    get_numeric_cols,
+    overview,
+)
+from .quality import (
+    constant_and_id_cols,
+    duplicates,
+    inconsistent_categories,
+    nulls,
+    outlier_report,
+)
+from .stats import describe_plus, unique_report
+from .plots import (
+    plot_categorical_counts,
+    plot_correlation,
+    plot_missing,
+    plot_numeric_distributions,
+    plot_target_relationship,
+)
+from .compare import check_merge_keys, compare_dfs
+from .report import quick_report
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "overview",
+    "dtypes_report",
+    "get_numeric_cols",
+    "get_categorical_cols",
+    "get_datetime_cols",
+    "nulls",
+    "duplicates",
+    "constant_and_id_cols",
+    "inconsistent_categories",
+    "outlier_report",
+    "describe_plus",
+    "unique_report",
+    "plot_numeric_distributions",
+    "plot_categorical_counts",
+    "plot_correlation",
+    "plot_target_relationship",
+    "plot_missing",
+    "compare_dfs",
+    "check_merge_keys",
+    "quick_report",
+]

edasnap-0.1.0/src/edasnap/compare.py

@@ -0,0 +1,64 @@
+"""Two-dataframe comparison and merge-key diagnostics."""
+
+from __future__ import annotations
+
+import pandas as pd
+
+
+def compare_dfs(df1: pd.DataFrame, df2: pd.DataFrame) -> dict:
+    """Shared/added/removed columns, dtype mismatches on shared columns, row-count diff."""
+    cols1, cols2 = set(df1.columns), set(df2.columns)
+    shared = sorted(cols1 & cols2)
+
+    dtype_mismatches = {
+        col: {"df1": str(df1[col].dtype), "df2": str(df2[col].dtype)}
+        for col in shared
+        if df1[col].dtype != df2[col].dtype
+    }
+
+    return {
+        "shared_columns": shared,
+        "only_in_df1": sorted(cols1 - cols2),
+        "only_in_df2": sorted(cols2 - cols1),
+        "dtype_mismatches": dtype_mismatches,
+        "row_count_df1": len(df1),
+        "row_count_df2": len(df2),
+    }
+
+
+def check_merge_keys(df1: pd.DataFrame, df2: pd.DataFrame, on: str | list) -> dict:
+    """Diagnose a proposed join key: dtype mismatch, missing keys each side, duplicate keys each side."""
+    keys = [on] if isinstance(on, str) else list(on)
+    for key in keys:
+        if key not in df1.columns:
+            raise ValueError(f"'{key}' not found in df1.")
+        if key not in df2.columns:
+            raise ValueError(f"'{key}' not found in df2.")
+
+    dtype_mismatches = {
+        key: {"df1": str(df1[key].dtype), "df2": str(df2[key].dtype)}
+        for key in keys
+        if df1[key].dtype != df2[key].dtype
+    }
+
+    left_keys = df1[keys].drop_duplicates()
+    right_keys = df2[keys].drop_duplicates()
+    merged = left_keys.merge(right_keys, on=keys, how="outer", indicator=True)
+
+    missing_in_df2 = int((merged["_merge"] == "left_only").sum())
+    missing_in_df1 = int((merged["_merge"] == "right_only").sum())
+
+    return {
+        "keys": keys,
+        "dtype_mismatches": dtype_mismatches,
+        "unique_keys_missing_in_df2": missing_in_df2,
+        "unique_keys_missing_in_df2_pct": round(missing_in_df2 / len(left_keys) * 100, 2)
+        if len(left_keys)
+        else 0.0,
+        "unique_keys_missing_in_df1": missing_in_df1,
+        "unique_keys_missing_in_df1_pct": round(missing_in_df1 / len(right_keys) * 100, 2)
+        if len(right_keys)
+        else 0.0,
+        "duplicate_key_rows_df1": int(df1.duplicated(subset=keys).sum()),
+        "duplicate_key_rows_df2": int(df2.duplicated(subset=keys).sum()),
+    }

edasnap-0.1.0/src/edasnap/overview.py

@@ -0,0 +1,54 @@
+"""Structural overview of a DataFrame: shape, dtypes, memory, column buckets."""
+
+import pandas as pd
+
+
+def overview(df: pd.DataFrame) -> dict:
+    """Shape, memory usage, and duplicate-row count in one dict."""
+    mem = df.memory_usage(deep=True)
+    return {
+        "rows": df.shape[0],
+        "columns": df.shape[1],
+        "duplicate_rows": int(df.duplicated().sum()),
+        "total_memory_mb": round(float(mem.sum()) / 1_000_000, 3),
+        "memory_by_column_mb": (mem.drop("Index", errors="ignore") / 1_000_000)
+        .round(4)
+        .sort_values(ascending=False)
+        .to_dict(),
+    }
+
+
+def dtypes_report(df: pd.DataFrame, high_cardinality_threshold: int = 50) -> dict:
+    """Bucket columns into numeric / categorical / datetime / boolean / text."""
+    buckets = {
+        "numeric": [],
+        "categorical": [],
+        "datetime": [],
+        "boolean": [],
+        "text": [],
+    }
+    for col in df.columns:
+        series = df[col]
+        if pd.api.types.is_bool_dtype(series):
+            buckets["boolean"].append(col)
+        elif pd.api.types.is_datetime64_any_dtype(series):
+            buckets["datetime"].append(col)
+        elif pd.api.types.is_numeric_dtype(series):
+            buckets["numeric"].append(col)
+        elif series.nunique(dropna=True) <= high_cardinality_threshold:
+            buckets["categorical"].append(col)
+        else:
+            buckets["text"].append(col)
+    return buckets
+
+
+def get_numeric_cols(df: pd.DataFrame) -> list:
+    return dtypes_report(df)["numeric"]
+
+
+def get_categorical_cols(df: pd.DataFrame) -> list:
+    return dtypes_report(df)["categorical"]
+
+
+def get_datetime_cols(df: pd.DataFrame) -> list:
+    return dtypes_report(df)["datetime"]

edasnap-0.1.0/src/edasnap/plots.py

@@ -0,0 +1,136 @@
+"""Auto-grid plotting helpers. Every function returns the matplotlib Figure it built."""
+
+from __future__ import annotations
+
+import math
+
+import matplotlib.pyplot as plt
+import pandas as pd
+
+from .overview import get_categorical_cols, get_numeric_cols
+
+
+def _grid_shape(n: int, max_cols: int = 3) -> tuple:
+    ncols = min(max_cols, n) or 1
+    nrows = math.ceil(n / ncols)
+    return nrows, ncols
+
+
+def plot_numeric_distributions(df: pd.DataFrame, columns: list | None = None, max_cols: int = 3):
+    """Histogram + boxplot grid for every numeric column."""
+    cols = columns or get_numeric_cols(df)
+    if not cols:
+        raise ValueError("No numeric columns found to plot.")
+
+    nrows, ncols = _grid_shape(len(cols), max_cols)
+    fig, axes = plt.subplots(nrows, ncols * 2, figsize=(4.5 * ncols * 2, 3.5 * nrows))
+    axes = axes.reshape(nrows, ncols * 2)
+
+    for i, col in enumerate(cols):
+        r, c = divmod(i, ncols)
+        hist_ax, box_ax = axes[r, c * 2], axes[r, c * 2 + 1]
+        df[col].dropna().hist(ax=hist_ax, bins=30)
+        hist_ax.set_title(f"{col} (hist)")
+        box_ax.boxplot(df[col].dropna())
+        box_ax.set_title(f"{col} (box)")
+
+    for j in range(len(cols), nrows * ncols):
+        r, c = divmod(j, ncols)
+        axes[r, c * 2].axis("off")
+        axes[r, c * 2 + 1].axis("off")
+
+    fig.tight_layout()
+    return fig
+
+
+def plot_categorical_counts(df: pd.DataFrame, columns: list | None = None, top_n: int = 10, max_cols: int = 3):
+    """Bar chart grid for every categorical column, capped at top_n categories."""
+    cols = columns or get_categorical_cols(df)
+    if not cols:
+        raise ValueError("No categorical columns found to plot.")
+
+    nrows, ncols = _grid_shape(len(cols), max_cols)
+    fig, axes = plt.subplots(nrows, ncols, figsize=(5 * ncols, 3.5 * nrows), squeeze=False)
+
+    for i, col in enumerate(cols):
+        r, c = divmod(i, ncols)
+        counts = df[col].value_counts().head(top_n)
+        counts.plot(kind="bar", ax=axes[r, c])
+        axes[r, c].set_title(col)
+        axes[r, c].tick_params(axis="x", rotation=45)
+
+    for j in range(len(cols), nrows * ncols):
+        r, c = divmod(j, ncols)
+        axes[r, c].axis("off")
+
+    fig.tight_layout()
+    return fig
+
+
+def plot_correlation(df: pd.DataFrame, method: str = "pearson", sample: int | None = None):
+    """Masked correlation heatmap over numeric columns."""
+    import numpy as np
+    import seaborn as sns
+
+    data = df if sample is None or len(df) <= sample else df.sample(sample, random_state=0)
+    numeric_cols = get_numeric_cols(data)
+    if len(numeric_cols) < 2:
+        raise ValueError("Need at least 2 numeric columns to plot a correlation heatmap.")
+
+    corr = data[numeric_cols].corr(method=method)
+    mask = np.triu(np.ones_like(corr, dtype=bool))
+
+    fig, ax = plt.subplots(figsize=(0.8 * len(numeric_cols) + 2, 0.8 * len(numeric_cols) + 2))
+    sns.heatmap(corr, mask=mask, annot=True, fmt=".2f", cmap="coolwarm", center=0, ax=ax)
+    fig.tight_layout()
+    return fig
+
+
+def plot_target_relationship(df: pd.DataFrame, target: str, max_cols: int = 3):
+    """Boxplot/violin (categorical feature) or scatter (numeric feature) vs. target."""
+    if target not in df.columns:
+        raise ValueError(f"'{target}' is not a column in the DataFrame.")
+
+    feature_cols = [c for c in df.columns if c != target]
+    numeric_target = pd.api.types.is_numeric_dtype(df[target])
+
+    nrows, ncols = _grid_shape(len(feature_cols), max_cols)
+    fig, axes = plt.subplots(nrows, ncols, figsize=(5 * ncols, 3.5 * nrows), squeeze=False)
+
+    for i, col in enumerate(feature_cols):
+        r, c = divmod(i, ncols)
+        ax = axes[r, c]
+        is_numeric_feature = pd.api.types.is_numeric_dtype(df[col])
+
+        if is_numeric_feature and numeric_target:
+            ax.scatter(df[col], df[target], alpha=0.4, s=10)
+            ax.set_xlabel(col)
+            ax.set_ylabel(target)
+        elif not is_numeric_feature and numeric_target:
+            df.boxplot(column=target, by=col, ax=ax)
+            ax.set_title(f"{target} by {col}")
+        elif is_numeric_feature and not numeric_target:
+            df.boxplot(column=col, by=target, ax=ax)
+            ax.set_title(f"{col} by {target}")
+        else:
+            pd.crosstab(df[col], df[target]).plot(kind="bar", stacked=True, ax=ax, legend=False)
+            ax.set_title(f"{col} vs {target}")
+
+    for j in range(len(feature_cols), nrows * ncols):
+        r, c = divmod(j, ncols)
+        axes[r, c].axis("off")
+
+    fig.suptitle("")
+    fig.tight_layout()
+    return fig
+
+
+def plot_missing(df: pd.DataFrame):
+    """Heatmap of null locations across the DataFrame."""
+    import seaborn as sns
+
+    fig, ax = plt.subplots(figsize=(0.3 * len(df.columns) + 4, 5))
+    sns.heatmap(df.isna(), cbar=False, yticklabels=False, ax=ax)
+    ax.set_title("Missing value pattern")
+    fig.tight_layout()
+    return fig

edasnap-0.1.0/src/edasnap/quality.py

@@ -0,0 +1,103 @@
+"""Data-quality checks: nulls, duplicates, constant/ID columns, messy categories, outliers."""
+
+from __future__ import annotations
+
+import re
+
+import pandas as pd
+
+from .overview import get_numeric_cols
+
+
+def nulls(df: pd.DataFrame) -> pd.DataFrame:
+    """% missing per column, sorted descending, nulls-only columns."""
+    counts = df.isna().sum()
+    counts = counts[counts > 0]
+    if counts.empty:
+        return pd.DataFrame(columns=["null_count", "null_pct"])
+    pct = (counts / len(df) * 100).round(2)
+    result = pd.DataFrame({"null_count": counts, "null_pct": pct})
+    return result.sort_values("null_pct", ascending=False)
+
+
+def duplicates(df: pd.DataFrame, subset: list | None = None) -> dict:
+    """Count and preview of duplicate rows, optionally restricted to a column subset."""
+    mask = df.duplicated(subset=subset, keep=False)
+    dup_rows = df[mask]
+    return {
+        "duplicate_row_count": int(df.duplicated(subset=subset).sum()),
+        "duplicate_pct": round(df.duplicated(subset=subset).sum() / len(df) * 100, 2)
+        if len(df)
+        else 0.0,
+        "preview": dup_rows.head(10),
+    }
+
+
+def constant_and_id_cols(df: pd.DataFrame) -> dict:
+    """Flag constant columns (nunique==1) and likely-ID columns (nunique==len(df))."""
+    n = len(df)
+    constant_cols, id_cols = [], []
+    for col in df.columns:
+        nunique = df[col].nunique(dropna=False)
+        if nunique <= 1:
+            constant_cols.append(col)
+        elif n > 0 and nunique == n:
+            id_cols.append(col)
+    return {"constant_columns": constant_cols, "likely_id_columns": id_cols}
+
+
+def _normalize(value: str) -> str:
+    value = value.strip().lower()
+    return re.sub(r"[^a-z0-9]", "", value)
+
+
+def inconsistent_categories(df: pd.DataFrame, columns: list | None = None) -> dict:
+    """Flag values that likely represent the same category due to case/whitespace/punctuation."""
+    target_cols = columns or [
+        c for c in df.columns if df[c].dtype == object or str(df[c].dtype) == "category"
+    ]
+    findings = {}
+    for col in target_cols:
+        values = df[col].dropna().astype(str).unique()
+        groups: dict[str, list] = {}
+        for v in values:
+            key = _normalize(v)
+            groups.setdefault(key, []).append(v)
+        messy = {k: sorted(v) for k, v in groups.items() if len(v) > 1}
+        if messy:
+            findings[col] = messy
+    return findings
+
+
+def outlier_report(df: pd.DataFrame, method: str = "iqr") -> pd.DataFrame:
+    """Per numeric column, count/percentage of outliers via IQR or z-score."""
+    if method not in {"iqr", "zscore"}:
+        raise ValueError("method must be 'iqr' or 'zscore'")
+
+    rows = []
+    for col in get_numeric_cols(df):
+        series = df[col].dropna()
+        if series.empty:
+            continue
+        if method == "iqr":
+            q1, q3 = series.quantile(0.25), series.quantile(0.75)
+            iqr = q3 - q1
+            lower, upper = q1 - 1.5 * iqr, q3 + 1.5 * iqr
+            outlier_mask = (series < lower) | (series > upper)
+        else:
+            std = series.std()
+            if std == 0 or pd.isna(std):
+                outlier_mask = pd.Series(False, index=series.index)
+            else:
+                z = (series - series.mean()) / std
+                outlier_mask = z.abs() > 3
+
+        count = int(outlier_mask.sum())
+        rows.append(
+            {
+                "column": col,
+                "outlier_count": count,
+                "outlier_pct": round(count / len(series) * 100, 2),
+            }
+        )
+    return pd.DataFrame(rows).sort_values("outlier_pct", ascending=False).reset_index(drop=True)

edasnap-0.1.0/src/edasnap/report.py

@@ -0,0 +1,51 @@
+"""One guided function that chains the atomic checks in a sensible order."""
+
+import pandas as pd
+
+from .overview import dtypes_report, overview
+from .quality import constant_and_id_cols, duplicates, nulls
+
+try:
+    from IPython.display import display
+
+    _IN_NOTEBOOK = True
+except ImportError:
+    _IN_NOTEBOOK = False
+
+
+def _show(label, value):
+    print(f"\n--- {label} ---")
+    if _IN_NOTEBOOK and isinstance(value, pd.DataFrame):
+        display(value)
+    else:
+        print(value)
+
+
+def quick_report(df: pd.DataFrame, plot: bool = True) -> dict:
+    """Run overview, nulls, dtypes, duplicates, and constant/ID checks in one call.
+
+    Prints a readable summary and returns everything as a dict so each
+    piece stays usable on its own.
+    """
+    result = {
+        "overview": overview(df),
+        "nulls": nulls(df),
+        "dtypes": dtypes_report(df),
+        "duplicates": duplicates(df),
+        "constant_and_id": constant_and_id_cols(df),
+    }
+
+    _show("Overview", result["overview"])
+    _show("Nulls", result["nulls"] if not result["nulls"].empty else "No missing values.")
+    _show("Column types", result["dtypes"])
+    _show("Duplicate rows", result["duplicates"]["duplicate_row_count"])
+    _show("Constant / likely-ID columns", result["constant_and_id"])
+
+    if plot:
+        from .plots import plot_numeric_distributions
+
+        numeric_cols = result["dtypes"]["numeric"]
+        if numeric_cols:
+            result["numeric_distributions_fig"] = plot_numeric_distributions(df, columns=numeric_cols)
+
+    return result

edasnap-0.1.0/src/edasnap/stats.py

@@ -0,0 +1,35 @@
+"""Summary statistics beyond plain .describe()."""
+
+import pandas as pd
+
+from .overview import get_numeric_cols
+
+
+def describe_plus(df: pd.DataFrame) -> pd.DataFrame:
+    """.describe() plus null %, skew, kurtosis, and dtype, for numeric columns."""
+    numeric_cols = get_numeric_cols(df)
+    if not numeric_cols:
+        return pd.DataFrame()
+
+    base = df[numeric_cols].describe().T
+    base["null_pct"] = (df[numeric_cols].isna().sum() / len(df) * 100).round(2)
+    base["skew"] = df[numeric_cols].skew()
+    base["kurtosis"] = df[numeric_cols].kurt()
+    base["dtype"] = df[numeric_cols].dtypes.astype(str)
+    return base
+
+
+def unique_report(df: pd.DataFrame, examples: int = 3) -> pd.DataFrame:
+    """nunique + example values per column."""
+    rows = []
+    for col in df.columns:
+        series = df[col]
+        sample = series.dropna().unique()[:examples]
+        rows.append(
+            {
+                "column": col,
+                "nunique": series.nunique(dropna=True),
+                "examples": list(sample),
+            }
+        )
+    return pd.DataFrame(rows).sort_values("nunique", ascending=False).reset_index(drop=True)

edasnap-0.1.0/src/edasnap.egg-info/PKG-INFO

@@ -0,0 +1,162 @@
+Metadata-Version: 2.4
+Name: edasnap
+Version: 0.1.0
+Summary: A fast, honest first look at any pandas DataFrame — one-liner EDA helpers, no bloat.
+Author: sivaraam.kr
+License: MIT
+Project-URL: Homepage, https://github.com/sivaraam-kr/edasnap
+Project-URL: Issues, https://github.com/sivaraam-kr/edasnap/issues
+Keywords: eda,exploratory-data-analysis,pandas,data-science,data-quality
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Education
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=1.3
+Requires-Dist: matplotlib>=3.4
+Requires-Dist: seaborn>=0.11
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: license-file
+
+# edasnap
+
+**A fast, honest first look at any pandas DataFrame — in one line each.**
+
+`edasnap` answers the questions you ask every single time you load a new
+dataset: What's the shape? What's null, and how much? What are my numeric
+vs. categorical columns? Are there duplicate rows, constant columns, or
+columns that are secretly IDs? Do `"USA"`, `"usa "`, and `"U.S.A"` need to
+be merged into one category? Will this merge silently blow up my row count?
+
+It's built to be the opposite of a giant auto-generated HTML report:
+
+- **One function, one job.** No monolithic `report()` that dumps 40 sections
+  you didn't ask for — call only what you need.
+- **Every function returns real data** (a `dict`, a `DataFrame`, a
+  matplotlib `Figure`) — never just a printout you can't reuse.
+- **Never mutates your DataFrame.** Everything is read-only analysis.
+- **Small on purpose.** Just pandas EDA — no bundled ML training, no
+  encoding pipelines, no computer vision, no LLM calls. It's a lens on your
+  data, not a pipeline.
+- **Doesn't crash on messy real data** — mixed types, weird strings, and
+  edge cases (empty df, all-null column, single row) are handled, not
+  fatal.
+- **Readable source.** Every function is short enough to read in ten
+  seconds if you're curious what it's actually doing — handy if you're
+  still learning pandas.
+
+## Install
+
+```bash
+pip install edasnap
+```
+
+## Quickstart
+
+```python
+import pandas as pd
+import edasnap as es
+
+df = pd.read_csv("data.csv")
+
+es.quick_report(df)   # runs the core checks below, in a sensible order
+```
+
+## All functions
+
+### Structure & column types
+
+| Function | What it tells you |
+|---|---|
+| `es.overview(df)` | Row/column count, total + per-column memory usage, duplicate row count |
+| `es.dtypes_report(df)` | Buckets every column into `numeric`, `categorical`, `datetime`, `boolean`, or `text` |
+| `es.get_numeric_cols(df)` | List of numeric column names — ready to hand to a plot or model |
+| `es.get_categorical_cols(df)` | List of categorical column names |
+| `es.get_datetime_cols(df)` | List of datetime column names |
+
+```python
+es.overview(df)
+# {'rows': 891, 'columns': 12, 'duplicate_rows': 0,
+#  'total_memory_mb': 0.29, 'memory_by_column_mb': {...}}
+
+es.dtypes_report(df)
+# {'numeric': ['Age', 'Fare'], 'categorical': ['Sex', 'Embarked'], ...}
+```
+
+### Data quality
+
+| Function | What it tells you |
+|---|---|
+| `es.nulls(df)` | % missing per column, worst first — only columns that actually have nulls |
+| `es.duplicates(df, subset=None)` | Duplicate row count, % of the dataset, and a preview |
+| `es.constant_and_id_cols(df)` | Columns with only one value (dead weight), and columns that are likely IDs (`nunique == len(df)`) — both are common "don't feed this to a model" traps |
+| `es.inconsistent_categories(df)` | Flags values in text columns that are probably the same category typed differently — `"USA"` / `"usa "` / `"U.S.A"` — a check the bigger EDA tools skip |
+| `es.outlier_report(df, method="iqr")` | Outlier count and % per numeric column, via IQR or z-score — as a table, no plot needed |
+
+```python
+es.nulls(df)
+#           null_count  null_pct
+# Cabin            687     77.10
+# Age               177     19.87
+
+es.inconsistent_categories(df)
+# {'country': {'usa': ['USA', 'usa ', 'U.S.A'], 'uk': ['UK', 'uk']}}
+```
+
+### Summary stats
+
+| Function | What it tells you |
+|---|---|
+| `es.describe_plus(df)` | `.describe()` plus null %, skew, kurtosis, and dtype in one table |
+| `es.unique_report(df)` | `nunique` + a few example values per column |
+
+### Plots (each returns the matplotlib `Figure`)
+
+| Function | What it draws |
+|---|---|
+| `es.plot_numeric_distributions(df)` | Histogram + boxplot grid, one pair per numeric column |
+| `es.plot_categorical_counts(df, top_n=10)` | Bar chart grid per categorical column, capped at the top N values |
+| `es.plot_correlation(df)` | Masked correlation heatmap over numeric columns |
+| `es.plot_target_relationship(df, target="price")` | Auto-picks boxplot/violin/scatter per feature against your target column |
+| `es.plot_missing(df)` | Heatmap of where nulls occur across the whole DataFrame |
+
+### Comparing two DataFrames
+
+| Function | What it tells you |
+|---|---|
+| `es.compare_dfs(train_df, test_df)` | Shared/added/removed columns and dtype mismatches between two DataFrames — e.g. train vs. test drift |
+| `es.check_merge_keys(orders_df, users_df, on="user_id")` | Before you `merge()`: dtype mismatch on the key, % of keys missing on each side, and duplicate-key counts on each side — the usual cause of a merge silently multiplying your row count |
+
+### The one convenience function
+
+| Function | What it does |
+|---|---|
+| `es.quick_report(df)` | Chains `overview` → `nulls` → `dtypes_report` → `duplicates` → `constant_and_id_cols` → a numeric-distribution plot, prints a readable summary, and returns everything as a dict. Every piece it calls also works standalone. |
+
+## Development
+
+```bash
+git clone https://github.com/sivaraam-kr/edasnap
+cd edasnap
+pip install -e ".[dev]"
+pytest
+```
+
+## Publishing
+
+See [PUBLISHING.md](PUBLISHING.md) for the release checklist.
+
+## License
+
+MIT

edasnap-0.1.0/src/edasnap.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+LICENSE
+README.md
+pyproject.toml
+src/edasnap/__init__.py
+src/edasnap/compare.py
+src/edasnap/overview.py
+src/edasnap/plots.py
+src/edasnap/quality.py
+src/edasnap/report.py
+src/edasnap/stats.py
+src/edasnap.egg-info/PKG-INFO
+src/edasnap.egg-info/SOURCES.txt
+src/edasnap.egg-info/dependency_links.txt
+src/edasnap.egg-info/requires.txt
+src/edasnap.egg-info/top_level.txt
+tests/test_compare.py
+tests/test_overview.py
+tests/test_plots.py
+tests/test_quality.py
+tests/test_report.py
+tests/test_stats.py

edasnap-0.1.0/src/edasnap.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

edasnap-0.1.0/src/edasnap.egg-info/requires.txt

@@ -0,0 +1,8 @@
+pandas>=1.3
+matplotlib>=3.4
+seaborn>=0.11
+
+[dev]
+pytest>=7.0
+build
+twine

edasnap-0.1.0/src/edasnap.egg-info/top_level.txt

@@ -0,0 +1 @@
+edasnap

edasnap-0.1.0/tests/test_compare.py

@@ -0,0 +1,38 @@
+import pandas as pd
+
+import edasnap as es
+
+
+def test_compare_dfs_columns():
+    df1 = pd.DataFrame({"a": [1], "b": [2]})
+    df2 = pd.DataFrame({"a": [1], "c": [3]})
+    result = es.compare_dfs(df1, df2)
+    assert result["shared_columns"] == ["a"]
+    assert result["only_in_df1"] == ["b"]
+    assert result["only_in_df2"] == ["c"]
+
+
+def test_compare_dfs_dtype_mismatch():
+    df1 = pd.DataFrame({"a": [1, 2]})
+    df2 = pd.DataFrame({"a": ["1", "2"]})
+    result = es.compare_dfs(df1, df2)
+    assert "a" in result["dtype_mismatches"]
+
+
+def test_check_merge_keys_detects_missing_and_duplicates():
+    df1 = pd.DataFrame({"id": [1, 2, 2, 3]})
+    df2 = pd.DataFrame({"id": [2, 3, 4]})
+    result = es.check_merge_keys(df1, df2, on="id")
+    assert result["unique_keys_missing_in_df2"] == 1
+    assert result["unique_keys_missing_in_df1"] == 1
+    assert result["duplicate_key_rows_df1"] == 1
+
+
+def test_check_merge_keys_missing_column_raises():
+    df1 = pd.DataFrame({"id": [1]})
+    df2 = pd.DataFrame({"other": [1]})
+    try:
+        es.check_merge_keys(df1, df2, on="id")
+        assert False, "expected ValueError"
+    except ValueError:
+        pass

edasnap-0.1.0/tests/test_overview.py

@@ -0,0 +1,38 @@
+import pandas as pd
+
+import edasnap as es
+
+
+def test_overview_basic(sample_df):
+    result = es.overview(sample_df)
+    assert result["rows"] == 10
+    assert result["columns"] == 6
+    assert result["duplicate_rows"] == 0
+    assert result["total_memory_mb"] > 0
+
+
+def test_overview_empty(empty_df):
+    result = es.overview(empty_df)
+    assert result["rows"] == 0
+    assert result["columns"] == 0
+
+
+def test_dtypes_report_buckets(sample_df):
+    report = es.dtypes_report(sample_df)
+    assert "age" in report["numeric"]
+    assert "score" in report["numeric"]
+    assert "flag" in report["boolean"]
+    assert "country" in report["categorical"]
+
+
+def test_get_numeric_cols(sample_df):
+    assert set(es.get_numeric_cols(sample_df)) >= {"id", "age", "score"}
+
+
+def test_get_categorical_cols(sample_df):
+    assert "country" in es.get_categorical_cols(sample_df)
+
+
+def test_dtypes_report_datetime():
+    df = pd.DataFrame({"d": pd.date_range("2024-01-01", periods=5)})
+    assert es.get_datetime_cols(df) == ["d"]

edasnap-0.1.0/tests/test_plots.py

@@ -0,0 +1,30 @@
+import matplotlib
+
+matplotlib.use("Agg")
+
+import edasnap as es
+
+
+def test_plot_numeric_distributions_returns_figure(sample_df):
+    fig = es.plot_numeric_distributions(sample_df)
+    assert fig is not None
+
+
+def test_plot_categorical_counts_returns_figure(sample_df):
+    fig = es.plot_categorical_counts(sample_df)
+    assert fig is not None
+
+
+def test_plot_correlation_returns_figure(sample_df):
+    fig = es.plot_correlation(sample_df)
+    assert fig is not None
+
+
+def test_plot_target_relationship_numeric_target(sample_df):
+    fig = es.plot_target_relationship(sample_df.drop(columns=["constant"]), target="score")
+    assert fig is not None
+
+
+def test_plot_missing_returns_figure(sample_df):
+    fig = es.plot_missing(sample_df)
+    assert fig is not None

edasnap-0.1.0/tests/test_quality.py

@@ -0,0 +1,69 @@
+import pandas as pd
+
+import edasnap as es
+
+
+def test_nulls_reports_only_null_columns(sample_df):
+    result = es.nulls(sample_df)
+    assert set(result.index) == {"age", "score"}
+    assert result.loc["age", "null_count"] == 1
+
+
+def test_nulls_empty_when_no_nulls():
+    df = pd.DataFrame({"a": [1, 2, 3]})
+    result = es.nulls(df)
+    assert result.empty
+
+
+def test_duplicates_counts_correctly():
+    df = pd.DataFrame({"a": [1, 1, 2, 3], "b": [1, 1, 2, 3]})
+    result = es.duplicates(df)
+    assert result["duplicate_row_count"] == 1
+
+
+def test_duplicates_on_empty_df(empty_df):
+    result = es.duplicates(empty_df)
+    assert result["duplicate_row_count"] == 0
+    assert result["duplicate_pct"] == 0.0
+
+
+def test_constant_and_id_cols(sample_df):
+    result = es.constant_and_id_cols(sample_df)
+    assert "constant" in result["constant_columns"]
+    assert "id" in result["likely_id_columns"]
+
+
+def test_inconsistent_categories_groups_variants(sample_df):
+    findings = es.inconsistent_categories(sample_df, columns=["country"])
+    assert "country" in findings
+    groups = findings["country"]
+    usa_group = [g for g in groups.values() if "USA" in g][0]
+    assert set(usa_group) == {"USA", "usa ", "U.S.A"}
+
+
+def test_inconsistent_categories_no_false_positive():
+    df = pd.DataFrame({"c": ["apple", "banana", "cherry"]})
+    findings = es.inconsistent_categories(df)
+    assert findings == {}
+
+
+def test_outlier_report_iqr(sample_df):
+    result = es.outlier_report(sample_df, method="iqr")
+    row = result[result["column"] == "age"].iloc[0]
+    assert row["outlier_count"] >= 1
+
+
+def test_outlier_report_invalid_method(sample_df):
+    try:
+        es.outlier_report(sample_df, method="bogus")
+        assert False, "expected ValueError"
+    except ValueError:
+        pass
+
+
+def test_quality_functions_handle_messy_data(messy_df):
+    es.nulls(messy_df)
+    es.duplicates(messy_df)
+    es.constant_and_id_cols(messy_df)
+    es.inconsistent_categories(messy_df)
+    es.outlier_report(messy_df)

edasnap-0.1.0/tests/test_report.py

@@ -0,0 +1,19 @@
+import matplotlib
+
+matplotlib.use("Agg")
+
+import edasnap as es
+
+
+def test_quick_report_returns_all_pieces(sample_df):
+    result = es.quick_report(sample_df)
+    assert "overview" in result
+    assert "nulls" in result
+    assert "dtypes" in result
+    assert "duplicates" in result
+    assert "constant_and_id" in result
+
+
+def test_quick_report_without_plot(sample_df):
+    result = es.quick_report(sample_df, plot=False)
+    assert "numeric_distributions_fig" not in result

edasnap-0.1.0/tests/test_stats.py

@@ -0,0 +1,22 @@
+import pandas as pd
+
+import edasnap as es
+
+
+def test_describe_plus_has_expected_columns(sample_df):
+    result = es.describe_plus(sample_df)
+    for col in ["null_pct", "skew", "kurtosis", "dtype"]:
+        assert col in result.columns
+    assert "age" in result.index
+
+
+def test_describe_plus_no_numeric_cols():
+    df = pd.DataFrame({"c": ["a", "b"]})
+    result = es.describe_plus(df)
+    assert result.empty
+
+
+def test_unique_report(sample_df):
+    result = es.unique_report(sample_df)
+    row = result[result["column"] == "constant"].iloc[0]
+    assert row["nunique"] == 1