tablofy 1.0.0a0__tar.gz

tablofy-1.0.0a0/LICENSE

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

tablofy-1.0.0a0/PKG-INFO

@@ -0,0 +1,242 @@
+Metadata-Version: 2.4
+Name: tablofy
+Version: 1.0.0a0
+Summary: A beginner-friendly data analytics library wrapping pandas, matplotlib, seaborn, and DuckDB.
+Author: Tablofy Contributors
+License-Expression: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=2.0
+Requires-Dist: numpy>=1.24
+Requires-Dist: matplotlib>=3.7
+Requires-Dist: seaborn>=0.12
+Requires-Dist: plotly>=5.14
+Requires-Dist: duckdb>=0.8
+Requires-Dist: pyarrow>=12
+Requires-Dist: openpyxl>=3.1
+Requires-Dist: jinja2>=3.1
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: ruff>=0.1; extra == "dev"
+Requires-Dist: black>=23; extra == "dev"
+Requires-Dist: build>=1.0; extra == "dev"
+Requires-Dist: twine>=4.0; extra == "dev"
+Dynamic: license-file
+
+# Tablofy
+
+A beginner-friendly data analytics library for Python that wraps pandas, matplotlib, seaborn, and DuckDB under a simple, unified API.
+
+```python
+import tablofy as tf
+
+data = tf.load("sales.csv")
+data.clean()
+print(data.profile())
+data.chart("sales by month")
+print(data.insights())
+data.report("report.html")
+```
+
+## What problem does Tablofy solve?
+
+Pandas is powerful but has a steep learning curve. Tablofy wraps it so you can:
+
+- **Load** CSV, Excel, JSON, and Parquet with a single function
+- **Explore** your data with plain-English methods (`preview()`, `profile()`, `summary()`)
+- **Clean** everything in one call (`clean()`) — duplicates, missing values, column names, dates, whitespace
+- **Chart** without memorizing matplotlib or seaborn APIs
+- **Run SQL** directly on a DataFrame using DuckDB
+- **Report** with a single call to `report("report.html")`
+
+No complex pandas syntax. No plotting boilerplate. No separate SQL database setup.
+
+## Installation
+
+```bash
+pip install tablofy
+```
+
+Requires Python 3.9 or later.
+
+## Quick Start
+
+```python
+import tablofy as tf
+
+# Load a file
+data = tf.load("sales.csv")
+
+# Explore
+print(data.preview())        # first 5 rows
+print(data.shape())          # {"rows": 100, "columns": 8}
+print(data.columns())        # ["date", "region", "product", "sales"]
+print(data.profile())        # full dataset profile
+
+# Clean in one go
+data.clean()
+
+# Chart
+data.bar(x="region", y="sales")
+data.chart("sales by month")                     # plain English!
+
+# Get automated insights
+for note in data.insights():
+    print(f"  - {note}")
+
+# Run SQL
+print(data.sql("SELECT region, SUM(sales) FROM data GROUP BY region"))
+
+# Generate a report
+data.report("report.html")
+```
+
+## Supported file formats
+
+| Extension | Format | Load | Export |
+|-----------|--------|------|--------|
+| `.csv` | Comma-separated values | `tf.load()` | `data.export()` |
+| `.xlsx` | Excel workbook | `tf.load()` | `data.export()` |
+| `.xls` | Excel 97-2003 | `tf.load()` | — |
+| `.json` | JSON | `tf.load()` | `data.export()` |
+| `.parquet` | Apache Parquet | `tf.load()` | `data.export()` |
+
+## API overview
+
+### Loading
+
+| Method | Description |
+|--------|-------------|
+| `tf.load(path)` | Load a file (auto-detects format) |
+| `TablofyFrame(df, name)` | Wrap an existing pandas DataFrame |
+
+### Exploration
+
+| Method | Description |
+|--------|-------------|
+| `.preview(n=5)` | First *n* rows |
+| `.head(n=5)` | Alias for preview |
+| `.shape()` | Row and column counts (dict) |
+| `.columns()` | Column names (list) |
+| `.dtypes` | Column -> dtype mapping (dict) |
+| `.types()` | Column types and null counts (DataFrame) |
+| `.missing()` | Columns with null values (DataFrame) |
+| `.duplicates()` | Duplicate row stats (dict) |
+| `.summary()` | Descriptive statistics (DataFrame) |
+| `.profile()` | Full dataset profile (dict) |
+| `.size` | Total cell count (int) |
+| `len(data)` | Row count (int) |
+| `.to_pandas()` | Get the underlying pandas DataFrame |
+
+### Cleaning
+
+| Method | Description |
+|--------|-------------|
+| `.clean()` | Clean in-place: duplicates, missing, column names, dates, whitespace |
+| `.clean_report()` | Report of actions from last clean (dict) |
+
+### Transform
+
+| Method | Description |
+|--------|-------------|
+| `.select(*cols)` | New frame with only the given columns |
+| `.drop(col)` | New frame without a column |
+| `.rename(mapping)` | New frame with renamed columns |
+| `.sort(by, descending)` | New frame sorted by a column |
+| `.filter(expression)` | New frame filtered by a pandas query expression |
+| `.group(by)` | A `GroupedFrame` for `.sum()` / `.mean()` aggregation |
+| `.pivot(index, columns, values)` | Pivot table |
+| `.join(other, on, how)` | Merge two frames on a shared key |
+| `.export(path)` | Write to CSV, XLSX, JSON, or Parquet |
+
+### Visualization
+
+| Method | Description |
+|--------|-------------|
+| `.bar(x, y, save)` | Bar chart |
+| `.line(x, y, save)` | Line chart |
+| `.scatter(x, y, save)` | Scatter plot |
+| `.hist(col, save)` | Histogram |
+| `.box(x, y, save)` | Box plot |
+| `.heatmap(save)` | Correlation heatmap |
+| `.pairplot(save)` | Pairwise scatter matrix |
+| `.chart(description)` | Smart chart from plain English |
+
+### Analytics
+
+| Method | Description |
+|--------|-------------|
+| `.insights()` | Rule-based observations (list of strings) |
+| `.stats.describe()` | Descriptive statistics (DataFrame) |
+| `.stats.correlation()` | Correlation matrix (DataFrame) |
+| `.stats.covariance()` | Covariance matrix (DataFrame) |
+| `.stats.outliers(col)` | IQR outlier detection |
+| `.stats.mean(col)` | Mean of a column |
+| `.stats.median(col)` | Median of a column |
+| `.stats.std(col)` | Standard deviation |
+| `.stats.min(col)` | Minimum value |
+| `.stats.max(col)` | Maximum value |
+| `.stats.quantile(col, q)` | Quantile value |
+| `.stats.value_counts(col)` | Frequency counts (Series) |
+
+### SQL
+
+| Method | Description |
+|--------|-------------|
+| `.sql(query)` | Run read-only SQL via DuckDB (table name: `data`) |
+
+### Reports
+
+| Method | Description |
+|--------|-------------|
+| `.report(path)` | Generate HTML or Excel report |
+
+## Examples
+
+See the [`examples/`](examples/) directory for runnable scripts:
+
+| Script | What it shows |
+|--------|---------------|
+| `basic_usage.py` | Core workflow: load → inspect → clean → chart |
+| `exploration_demo.py` | All exploration methods |
+| `cleaning_demo.py` | Cleaning pipeline + report |
+| `transform_demo.py` | Select, filter, group, sort, pivot, chain |
+| `charts_demo.py` | All chart types + smart chart |
+| `analytics_demo.py` | Insights + statistics |
+| `sql_demo.py` | SQL queries + chaining |
+| `report_demo.py` | HTML + Excel reports |
+
+## What Tablofy is not
+
+- **Not a replacement for pandas** — you can always get the underlying DataFrame with `.to_pandas()`
+- **Not a big-data tool** — it operates in-memory on a single machine
+- **Not a machine-learning library** — no model training or prediction
+- **Not a dashboard tool** — reports are static HTML or Excel files
+- **Not a database** — SQL runs in-memory against the loaded DataFrame only
+
+## Roadmap
+
+- [x] Load CSV, Excel, JSON, Parquet
+- [x] Data exploration (profile, summary, missing, types)
+- [x] Data cleaning (duplicates, missing values, column names, dates)
+- [x] Transformations (select, drop, sort, filter, group, join)
+- [x] Visualization (bar, line, scatter, hist, box, heatmap, pairplot)
+- [x] Smart chart from plain-English descriptions
+- [x] Rule-based insights
+- [x] Statistical helpers (mean, median, outliers, correlation)
+- [x] SQL queries via DuckDB
+- [x] HTML and Excel reports
+- [ ] Interactive charts with Plotly
+- [ ] Time-series analysis helpers
+- [ ] More chart types (area, pie, violin)
+- [ ] Custom theme/style configuration
+- [ ] Integration with Jupyter Notebook widgets
+
+## Contributing
+
+Contributions are welcome! Open an issue or pull request on GitHub.
+
+## License
+
+MIT

tablofy-1.0.0a0/README.md

@@ -0,0 +1,216 @@
+# Tablofy
+
+A beginner-friendly data analytics library for Python that wraps pandas, matplotlib, seaborn, and DuckDB under a simple, unified API.
+
+```python
+import tablofy as tf
+
+data = tf.load("sales.csv")
+data.clean()
+print(data.profile())
+data.chart("sales by month")
+print(data.insights())
+data.report("report.html")
+```
+
+## What problem does Tablofy solve?
+
+Pandas is powerful but has a steep learning curve. Tablofy wraps it so you can:
+
+- **Load** CSV, Excel, JSON, and Parquet with a single function
+- **Explore** your data with plain-English methods (`preview()`, `profile()`, `summary()`)
+- **Clean** everything in one call (`clean()`) — duplicates, missing values, column names, dates, whitespace
+- **Chart** without memorizing matplotlib or seaborn APIs
+- **Run SQL** directly on a DataFrame using DuckDB
+- **Report** with a single call to `report("report.html")`
+
+No complex pandas syntax. No plotting boilerplate. No separate SQL database setup.
+
+## Installation
+
+```bash
+pip install tablofy
+```
+
+Requires Python 3.9 or later.
+
+## Quick Start
+
+```python
+import tablofy as tf
+
+# Load a file
+data = tf.load("sales.csv")
+
+# Explore
+print(data.preview())        # first 5 rows
+print(data.shape())          # {"rows": 100, "columns": 8}
+print(data.columns())        # ["date", "region", "product", "sales"]
+print(data.profile())        # full dataset profile
+
+# Clean in one go
+data.clean()
+
+# Chart
+data.bar(x="region", y="sales")
+data.chart("sales by month")                     # plain English!
+
+# Get automated insights
+for note in data.insights():
+    print(f"  - {note}")
+
+# Run SQL
+print(data.sql("SELECT region, SUM(sales) FROM data GROUP BY region"))
+
+# Generate a report
+data.report("report.html")
+```
+
+## Supported file formats
+
+| Extension | Format | Load | Export |
+|-----------|--------|------|--------|
+| `.csv` | Comma-separated values | `tf.load()` | `data.export()` |
+| `.xlsx` | Excel workbook | `tf.load()` | `data.export()` |
+| `.xls` | Excel 97-2003 | `tf.load()` | — |
+| `.json` | JSON | `tf.load()` | `data.export()` |
+| `.parquet` | Apache Parquet | `tf.load()` | `data.export()` |
+
+## API overview
+
+### Loading
+
+| Method | Description |
+|--------|-------------|
+| `tf.load(path)` | Load a file (auto-detects format) |
+| `TablofyFrame(df, name)` | Wrap an existing pandas DataFrame |
+
+### Exploration
+
+| Method | Description |
+|--------|-------------|
+| `.preview(n=5)` | First *n* rows |
+| `.head(n=5)` | Alias for preview |
+| `.shape()` | Row and column counts (dict) |
+| `.columns()` | Column names (list) |
+| `.dtypes` | Column -> dtype mapping (dict) |
+| `.types()` | Column types and null counts (DataFrame) |
+| `.missing()` | Columns with null values (DataFrame) |
+| `.duplicates()` | Duplicate row stats (dict) |
+| `.summary()` | Descriptive statistics (DataFrame) |
+| `.profile()` | Full dataset profile (dict) |
+| `.size` | Total cell count (int) |
+| `len(data)` | Row count (int) |
+| `.to_pandas()` | Get the underlying pandas DataFrame |
+
+### Cleaning
+
+| Method | Description |
+|--------|-------------|
+| `.clean()` | Clean in-place: duplicates, missing, column names, dates, whitespace |
+| `.clean_report()` | Report of actions from last clean (dict) |
+
+### Transform
+
+| Method | Description |
+|--------|-------------|
+| `.select(*cols)` | New frame with only the given columns |
+| `.drop(col)` | New frame without a column |
+| `.rename(mapping)` | New frame with renamed columns |
+| `.sort(by, descending)` | New frame sorted by a column |
+| `.filter(expression)` | New frame filtered by a pandas query expression |
+| `.group(by)` | A `GroupedFrame` for `.sum()` / `.mean()` aggregation |
+| `.pivot(index, columns, values)` | Pivot table |
+| `.join(other, on, how)` | Merge two frames on a shared key |
+| `.export(path)` | Write to CSV, XLSX, JSON, or Parquet |
+
+### Visualization
+
+| Method | Description |
+|--------|-------------|
+| `.bar(x, y, save)` | Bar chart |
+| `.line(x, y, save)` | Line chart |
+| `.scatter(x, y, save)` | Scatter plot |
+| `.hist(col, save)` | Histogram |
+| `.box(x, y, save)` | Box plot |
+| `.heatmap(save)` | Correlation heatmap |
+| `.pairplot(save)` | Pairwise scatter matrix |
+| `.chart(description)` | Smart chart from plain English |
+
+### Analytics
+
+| Method | Description |
+|--------|-------------|
+| `.insights()` | Rule-based observations (list of strings) |
+| `.stats.describe()` | Descriptive statistics (DataFrame) |
+| `.stats.correlation()` | Correlation matrix (DataFrame) |
+| `.stats.covariance()` | Covariance matrix (DataFrame) |
+| `.stats.outliers(col)` | IQR outlier detection |
+| `.stats.mean(col)` | Mean of a column |
+| `.stats.median(col)` | Median of a column |
+| `.stats.std(col)` | Standard deviation |
+| `.stats.min(col)` | Minimum value |
+| `.stats.max(col)` | Maximum value |
+| `.stats.quantile(col, q)` | Quantile value |
+| `.stats.value_counts(col)` | Frequency counts (Series) |
+
+### SQL
+
+| Method | Description |
+|--------|-------------|
+| `.sql(query)` | Run read-only SQL via DuckDB (table name: `data`) |
+
+### Reports
+
+| Method | Description |
+|--------|-------------|
+| `.report(path)` | Generate HTML or Excel report |
+
+## Examples
+
+See the [`examples/`](examples/) directory for runnable scripts:
+
+| Script | What it shows |
+|--------|---------------|
+| `basic_usage.py` | Core workflow: load → inspect → clean → chart |
+| `exploration_demo.py` | All exploration methods |
+| `cleaning_demo.py` | Cleaning pipeline + report |
+| `transform_demo.py` | Select, filter, group, sort, pivot, chain |
+| `charts_demo.py` | All chart types + smart chart |
+| `analytics_demo.py` | Insights + statistics |
+| `sql_demo.py` | SQL queries + chaining |
+| `report_demo.py` | HTML + Excel reports |
+
+## What Tablofy is not
+
+- **Not a replacement for pandas** — you can always get the underlying DataFrame with `.to_pandas()`
+- **Not a big-data tool** — it operates in-memory on a single machine
+- **Not a machine-learning library** — no model training or prediction
+- **Not a dashboard tool** — reports are static HTML or Excel files
+- **Not a database** — SQL runs in-memory against the loaded DataFrame only
+
+## Roadmap
+
+- [x] Load CSV, Excel, JSON, Parquet
+- [x] Data exploration (profile, summary, missing, types)
+- [x] Data cleaning (duplicates, missing values, column names, dates)
+- [x] Transformations (select, drop, sort, filter, group, join)
+- [x] Visualization (bar, line, scatter, hist, box, heatmap, pairplot)
+- [x] Smart chart from plain-English descriptions
+- [x] Rule-based insights
+- [x] Statistical helpers (mean, median, outliers, correlation)
+- [x] SQL queries via DuckDB
+- [x] HTML and Excel reports
+- [ ] Interactive charts with Plotly
+- [ ] Time-series analysis helpers
+- [ ] More chart types (area, pie, violin)
+- [ ] Custom theme/style configuration
+- [ ] Integration with Jupyter Notebook widgets
+
+## Contributing
+
+Contributions are welcome! Open an issue or pull request on GitHub.
+
+## License
+
+MIT

tablofy-1.0.0a0/pyproject.toml

@@ -0,0 +1,51 @@
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tablofy"
+version = "1.0.0-alpha"
+description = "A beginner-friendly data analytics library wrapping pandas, matplotlib, seaborn, and DuckDB."
+readme = "README.md"
+license = "MIT"
+authors = [
+    { name = "Tablofy Contributors" },
+]
+requires-python = ">=3.9"
+dependencies = [
+    "pandas>=2.0",
+    "numpy>=1.24",
+    "matplotlib>=3.7",
+    "seaborn>=0.12",
+    "plotly>=5.14",
+    "duckdb>=0.8",
+    "pyarrow>=12",
+    "openpyxl>=3.1",
+    "jinja2>=3.1",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7",
+    "ruff>=0.1",
+    "black>=23",
+    "build>=1.0",
+    "twine>=4.0",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py39"
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I"]
+
+[tool.black]
+line-length = 100
+target-version = ["py39"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

tablofy-1.0.0a0/setup.cfg

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

tablofy-1.0.0a0/src/tablofy/__init__.py

@@ -0,0 +1,28 @@
+"""Tablofy — A beginner-friendly data analytics library."""
+
+__version__ = "1.0.0-alpha"
+
+from tablofy.core.errors import (
+    TablofyColumnError,
+    TablofyDataError,
+    TablofyError,
+    TablofyFileError,
+)
+from tablofy.core.frame import TablofyFrame
+from tablofy.core.loader import load
+
+ColumnNotFoundError = TablofyColumnError
+EmptyTableError = TablofyDataError
+FileFormatError = TablofyFileError
+
+__all__ = [
+    "TablofyFrame",
+    "load",
+    "TablofyError",
+    "TablofyFileError",
+    "TablofyColumnError",
+    "TablofyDataError",
+    "ColumnNotFoundError",
+    "EmptyTableError",
+    "FileFormatError",
+]

tablofy-1.0.0a0/src/tablofy/analytics/__init__.py

@@ -0,0 +1 @@
+"""Analytics: insights, statistics, outlier detection."""

tablofy-1.0.0a0/src/tablofy/analytics/insights.py

@@ -0,0 +1,130 @@
+"""Rule-based insight generation."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from tablofy.core.frame import TablofyFrame
+
+
+class Insights:
+    """Generates deterministic, rule-based observations about a dataset."""
+
+    def __init__(self, frame: TablofyFrame) -> None:
+        self._frame = frame
+        self._df = frame._df
+
+    def generate(self) -> list[str]:
+        """Return a list of human-readable insight strings.
+
+        Checks performed
+        -----------------
+        - Dataset dimensions
+        - Missing values
+        - Duplicate rows
+        - Strong correlations
+        - High-cardinality columns
+        - Low-cardinality categorical columns
+        - Highest/lowest numeric values
+        - Outlier hints
+        """
+        insights: list[str] = []
+        df = self._df
+
+        rows, cols = df.shape
+        insights.append(f"Dataset has {rows} rows and {cols} columns.")
+
+        # Missing values
+        missing_counts = df.isna().sum()
+        total_missing = int(missing_counts.sum())
+        if total_missing:
+            pct = total_missing / df.size * 100
+            insights.append(
+                f"Found {total_missing} missing cell(s) ({pct:.1f}% of data)."
+            )
+            cols_with_missing = [c for c in df.columns if missing_counts[c] > 0]
+            insights.append(
+                f"Columns with missing values: {cols_with_missing}."
+            )
+        else:
+            insights.append("No missing values detected.")
+
+        # Duplicate rows
+        dup_count = int(df.duplicated().sum())
+        if dup_count:
+            dup_pct = dup_count / rows * 100
+            insights.append(
+                f"Found {dup_count} duplicate row(s) ({dup_pct:.1f}% of rows)."
+            )
+        else:
+            insights.append("No duplicate rows found.")
+
+        # Strong correlations
+        numeric = df.select_dtypes(include="number")
+        if numeric.shape[1] >= 2:
+            corr = numeric.corr().abs()
+            strong: list[str] = []
+            for i in range(len(corr.columns)):
+                for j in range(i + 1, len(corr.columns)):
+                    val = corr.iloc[i, j]
+                    if val >= 0.7:
+                        strong.append(
+                            f"{corr.columns[i]} — {corr.columns[j]} "
+                            f"(r = {corr.iloc[i, j]:.2f})"
+                        )
+            if strong:
+                insights.append(
+                    f"Strong correlations detected ({len(strong)}): "
+                    f"{'; '.join(strong)}."
+                )
+            else:
+                insights.append(
+                    "No strong correlations (|r| >= 0.7) found between numeric columns."
+                )
+
+        # High-cardinality columns
+        high_card = [
+            c for c in df.columns
+            if df[c].nunique() > 50 and df[c].nunique() == len(df)
+        ]
+        if high_card:
+            insights.append(
+                f"High-cardinality columns (unique ID-like): {high_card}."
+            )
+
+        # Low-cardinality categorical columns
+        obj_cols = df.select_dtypes(include=["object", "category"]).columns
+        low_card = [c for c in obj_cols if 2 <= df[c].nunique() <= 10]
+        if low_card:
+            insights.append(
+                f"Low-cardinality categorical columns ({len(low_card)}): "
+                f"{low_card}."
+            )
+
+        # Highest / lowest numeric
+        if numeric.shape[1] >= 1:
+            for col in numeric.columns:
+                max_val = df[col].max()
+                min_val = df[col].min()
+                insights.append(
+                    f"{col}: min = {min_val}, max = {max_val}."
+                )
+
+        # Outlier hints (IQR-based)
+        if numeric.shape[1] >= 1:
+            for col in numeric.columns:
+                q1 = df[col].quantile(0.25)
+                q3 = df[col].quantile(0.75)
+                iqr = q3 - q1
+                lower = q1 - 1.5 * iqr
+                upper = q3 + 1.5 * iqr
+                outlier_count = int(((df[col] < lower) | (df[col] > upper)).sum())
+                if outlier_count:
+                    pct = outlier_count / rows * 100
+                    insights.append(
+                        f"{col}: {outlier_count} potential outlier(s) "
+                        f"({pct:.1f}% of rows)."
+                    )
+
+        return insights