tigerdatalab 3.0.4__tar.gz

tigerdatalab-3.0.4/LICENSE

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

tigerdatalab-3.0.4/PKG-INFO

@@ -0,0 +1,235 @@
+Metadata-Version: 2.4
+Name: tigerdatalab
+Version: 3.0.4
+Summary: Automated Data Analytics + Data Quality + Visualization + BI + DataOps platform, built on pandas/numpy/duckdb/plotly.
+Author: Abhi
+License: MIT
+Project-URL: Homepage, https://github.com/abhi15724/tigerdatalab
+Project-URL: Repository, https://github.com/abhi15724/tigerdatalab
+Keywords: data-analysis,business-intelligence,eda,dataops,dashboard,pandas,duckdb,plotly
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+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: Topic :: Scientific/Engineering :: Information Analysis
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=1.5
+Requires-Dist: numpy>=1.23
+Requires-Dist: openpyxl>=3.1
+Requires-Dist: plotly>=5.18
+Requires-Dist: charset-normalizer>=3.0
+Provides-Extra: large
+Requires-Dist: duckdb>=0.10; extra == "large"
+Requires-Dist: pyarrow>=14.0; extra == "large"
+Provides-Extra: pdf
+Requires-Dist: reportlab>=4.0; extra == "pdf"
+Provides-Extra: all
+Requires-Dist: duckdb>=0.10; extra == "all"
+Requires-Dist: pyarrow>=14.0; extra == "all"
+Requires-Dist: reportlab>=4.0; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4; extra == "dev"
+Requires-Dist: pytest-cov>=4.1; extra == "dev"
+Dynamic: license-file
+
+# TigerDataLab
+
+**TigerDataLab** is an automated Data Analytics + Data Quality + Visualization
++ Business Intelligence + DataOps layer built **on top of** pandas, numpy,
+duckdb and plotly — not a replacement for them.
+
+```python
+import pandas as pd
+import numpy as np           # still there when you want low-level control
+
+import tigerdatalab as tdl
+
+result = tdl.analyze("sales.xlsx")
+print(result.summary())
+result.report("analysis")     # dashboard + PDF + HTML + JSON, all in one call
+```
+
+For very large data:
+
+```python
+data = tdl.large("sales.parquet")
+data.count()
+data.aggregate("category", "SUM(revenue) AS revenue", "SUM(profit) AS profit")
+```
+
+## Install
+
+```bash
+pip install tigerdatalab            # core (pandas, numpy, openpyxl, plotly)
+pip install "tigerdatalab[all]"     # + duckdb, pyarrow, reportlab (large data + PDF)
+```
+
+Local development:
+
+```bash
+git clone <repo>
+cd tigerdatalab
+pip install -e ".[all,dev]"
+```
+
+## What `analyze()` does automatically
+
+1. Loads CSV / Excel (.xlsx, .xlsm) / JSON / Parquet / SQL / SQLite / DuckDB files.
+2. Detects column data types (never runs `.quantile()` on boolean columns).
+3. Detects business semantics (revenue, cost, profit, quantity, customer,
+   product, category, date, discount, order, price) from column names,
+   dtypes and value patterns.
+4. Profiles data quality (missing values, duplicates, outliers, invalid
+   dates, negative values where they shouldn't occur) into a 0–100 score.
+5. Cleans conservatively (whitespace, date normalization, numeric coercion,
+   duplicate removal) — every operation is logged, nothing is silently
+   destroyed.
+6. Calculates business KPIs (revenue, profit, margin, AOV, ASP, customers,
+   orders, products, discounts).
+7. Computes a performance trend (daily/monthly, MoM/YoY/rolling average)
+   when a date + numeric metric pair exists — and degrades gracefully
+   (never crashes) when it doesn't.
+8. Runs category, product, and customer analysis (each degrades gracefully
+   with a clear message if the relevant identifier column isn't present —
+   it never invents numbers).
+9. Generates a rule-based, evidence-backed business insight engine
+   (finding → evidence → impact → recommendation), with no LLM required.
+10. Builds 11 chart types (column, bar, line, pie, donut, histogram,
+    scatter, box plot, heatmap, pareto, KPI cards) — each with explicit
+    title/x-axis/y-axis/metric/aggregation metadata.
+11. Renders a responsive, interactive Plotly dashboard, a static HTML
+    report, a professional PDF business report, and JSON exports.
+
+## Public API
+
+```python
+result = tdl.analyze("sales.xlsx")
+
+result.summary()          # str
+result.kpis()              # dict
+result.quality()           # dict
+result.statistics()        # dict
+result.trends()            # dict
+result.customers()         # dict
+result.products()          # dict
+result.categories()        # dict
+result.insights()          # list[dict] — severity/title/evidence/impact/recommendation
+result.recommendations()   # list[str]
+result.visualize()         # list[ChartSpec] — 12 chart types incl. KPI Cards
+result.growth()             # dict — growing/declining products & categories
+result.anomalies()          # dict — z-score anomaly rows/columns
+result.ask()                 # dict — answers to the standard business-question set
+result.ask("which_category_generates_the_most_revenue")  # single answer
+
+result.dashboard("analysis/dashboard.html")
+result.export("analysis")   # cleaned_data.xlsx, insights/quality/statistics/kpis.json
+result.report("analysis")   # export() + dashboard.html + analysis_report.html
+                             #   + business_insights.pdf + charts/*.html
+```
+
+## DataOps — controlled, audited writes
+
+```python
+data = tdl.open("sales.xlsx")
+
+data.update(where={"product_id": "SKU-1"}, values={"price": 499})
+data.insert({"product_id": "SKU-99", "product": "Mouse", "price": 399})
+data.delete(where={"product_id": "SKU-99"})
+data.upsert({"product_id": "SKU-1", "price": 509}, key="product_id")
+
+data.rollback()          # undo the last operation
+data.save()               # write back to the original file
+data.save_audit_log("analysis/audit.json")
+```
+
+`update()`/`delete()` raise a clear error (`UpdateMatchedZeroRowsError`,
+`DeleteMatchedZeroRowsError`) instead of silently doing nothing.
+
+## Large data (DuckDB-backed, lazy)
+
+```python
+data = tdl.large("large_sales.parquet")   # CSV/Parquet, no full pandas load
+data.count()
+data.aggregate("category", "SUM(revenue) AS revenue")
+data.query("SELECT category, AVG(revenue) FROM data GROUP BY category")  # destructive SQL is refused
+```
+
+## CLI
+
+```bash
+tigerdatalab analyze sales.csv
+tigerdatalab dashboard sales.csv -o analysis/dashboard.html
+tigerdatalab profile sales.csv
+tigerdatalab quality sales.csv
+tigerdatalab clean sales.csv -o cleaned.xlsx
+tigerdatalab report sales.csv -o analysis
+```
+
+## SQL files
+
+```python
+result = tdl.analyze("sales.sql")   # CREATE TABLE / INSERT INTO / SELECT
+```
+
+Executed via DuckDB (falls back to sqlite3 if duckdb isn't installed).
+`DROP` / `TRUNCATE` / `DELETE` / `ALTER` are always refused — use the
+DataOps API for explicit, audited writes instead.
+
+## Privacy & security
+
+Everything runs **locally**. TigerDataLab never uploads your data, never
+calls an external API by default, and never executes arbitrary shell
+commands from a dataset. The business-insight engine is fully deterministic
+and rule-based — no LLM key required. An `InsightProvider` interface exists
+for anyone who wants to plug in an optional LLM-backed provider later.
+
+## Project layout
+
+```
+tigerdatalab/
+├── core.py                 # AnalysisResult, analyze(), open(), large()
+├── config.py
+├── exceptions.py
+├── io/loaders.py           # csv/excel/json/parquet/sql/sqlite/duckdb loading
+├── quality/                # types.py, profiler.py, cleaning.py
+├── analytics/               # kpi.py, trends.py, customer.py, product.py, category.py, profitability.py
+├── insights/engine.py       # rule-based insight generation
+├── visualization/charts.py  # chart engine (11 chart types)
+├── dashboard/builder.py     # interactive HTML dashboard
+├── reporting/               # html.py, pdf.py, exporters.py
+├── dataops/asset.py         # update/insert/delete/upsert/merge/rollback/audit
+├── scale/duckdb_engine.py   # lazy large-data aggregation
+└── cli/main.py
+```
+
+## Testing
+
+```bash
+python -m pytest
+python examples/sales_analysis.py
+python examples/dataops_example.py
+python examples/large_data_example.py
+```
+
+31 tests cover CSV/Excel/Parquet/SQL loading, boolean-safe type detection,
+missing-date/no-trend handling, empty/one-column/categorical-only datasets,
+DataOps (insert/update/delete/upsert/rollback/audit), and DuckDB large-data
+aggregation.
+
+## Publishing to PyPI
+
+```bash
+pip install build twine
+python -m build
+twine upload dist/*
+```
+
+## Version
+
+3.0.0 — see `CHANGELOG.md` for the full list of fixes over the 2.2.0 prototype.

tigerdatalab-3.0.4/README.md

@@ -0,0 +1,195 @@
+# TigerDataLab
+
+**TigerDataLab** is an automated Data Analytics + Data Quality + Visualization
++ Business Intelligence + DataOps layer built **on top of** pandas, numpy,
+duckdb and plotly — not a replacement for them.
+
+```python
+import pandas as pd
+import numpy as np           # still there when you want low-level control
+
+import tigerdatalab as tdl
+
+result = tdl.analyze("sales.xlsx")
+print(result.summary())
+result.report("analysis")     # dashboard + PDF + HTML + JSON, all in one call
+```
+
+For very large data:
+
+```python
+data = tdl.large("sales.parquet")
+data.count()
+data.aggregate("category", "SUM(revenue) AS revenue", "SUM(profit) AS profit")
+```
+
+## Install
+
+```bash
+pip install tigerdatalab            # core (pandas, numpy, openpyxl, plotly)
+pip install "tigerdatalab[all]"     # + duckdb, pyarrow, reportlab (large data + PDF)
+```
+
+Local development:
+
+```bash
+git clone <repo>
+cd tigerdatalab
+pip install -e ".[all,dev]"
+```
+
+## What `analyze()` does automatically
+
+1. Loads CSV / Excel (.xlsx, .xlsm) / JSON / Parquet / SQL / SQLite / DuckDB files.
+2. Detects column data types (never runs `.quantile()` on boolean columns).
+3. Detects business semantics (revenue, cost, profit, quantity, customer,
+   product, category, date, discount, order, price) from column names,
+   dtypes and value patterns.
+4. Profiles data quality (missing values, duplicates, outliers, invalid
+   dates, negative values where they shouldn't occur) into a 0–100 score.
+5. Cleans conservatively (whitespace, date normalization, numeric coercion,
+   duplicate removal) — every operation is logged, nothing is silently
+   destroyed.
+6. Calculates business KPIs (revenue, profit, margin, AOV, ASP, customers,
+   orders, products, discounts).
+7. Computes a performance trend (daily/monthly, MoM/YoY/rolling average)
+   when a date + numeric metric pair exists — and degrades gracefully
+   (never crashes) when it doesn't.
+8. Runs category, product, and customer analysis (each degrades gracefully
+   with a clear message if the relevant identifier column isn't present —
+   it never invents numbers).
+9. Generates a rule-based, evidence-backed business insight engine
+   (finding → evidence → impact → recommendation), with no LLM required.
+10. Builds 11 chart types (column, bar, line, pie, donut, histogram,
+    scatter, box plot, heatmap, pareto, KPI cards) — each with explicit
+    title/x-axis/y-axis/metric/aggregation metadata.
+11. Renders a responsive, interactive Plotly dashboard, a static HTML
+    report, a professional PDF business report, and JSON exports.
+
+## Public API
+
+```python
+result = tdl.analyze("sales.xlsx")
+
+result.summary()          # str
+result.kpis()              # dict
+result.quality()           # dict
+result.statistics()        # dict
+result.trends()            # dict
+result.customers()         # dict
+result.products()          # dict
+result.categories()        # dict
+result.insights()          # list[dict] — severity/title/evidence/impact/recommendation
+result.recommendations()   # list[str]
+result.visualize()         # list[ChartSpec] — 12 chart types incl. KPI Cards
+result.growth()             # dict — growing/declining products & categories
+result.anomalies()          # dict — z-score anomaly rows/columns
+result.ask()                 # dict — answers to the standard business-question set
+result.ask("which_category_generates_the_most_revenue")  # single answer
+
+result.dashboard("analysis/dashboard.html")
+result.export("analysis")   # cleaned_data.xlsx, insights/quality/statistics/kpis.json
+result.report("analysis")   # export() + dashboard.html + analysis_report.html
+                             #   + business_insights.pdf + charts/*.html
+```
+
+## DataOps — controlled, audited writes
+
+```python
+data = tdl.open("sales.xlsx")
+
+data.update(where={"product_id": "SKU-1"}, values={"price": 499})
+data.insert({"product_id": "SKU-99", "product": "Mouse", "price": 399})
+data.delete(where={"product_id": "SKU-99"})
+data.upsert({"product_id": "SKU-1", "price": 509}, key="product_id")
+
+data.rollback()          # undo the last operation
+data.save()               # write back to the original file
+data.save_audit_log("analysis/audit.json")
+```
+
+`update()`/`delete()` raise a clear error (`UpdateMatchedZeroRowsError`,
+`DeleteMatchedZeroRowsError`) instead of silently doing nothing.
+
+## Large data (DuckDB-backed, lazy)
+
+```python
+data = tdl.large("large_sales.parquet")   # CSV/Parquet, no full pandas load
+data.count()
+data.aggregate("category", "SUM(revenue) AS revenue")
+data.query("SELECT category, AVG(revenue) FROM data GROUP BY category")  # destructive SQL is refused
+```
+
+## CLI
+
+```bash
+tigerdatalab analyze sales.csv
+tigerdatalab dashboard sales.csv -o analysis/dashboard.html
+tigerdatalab profile sales.csv
+tigerdatalab quality sales.csv
+tigerdatalab clean sales.csv -o cleaned.xlsx
+tigerdatalab report sales.csv -o analysis
+```
+
+## SQL files
+
+```python
+result = tdl.analyze("sales.sql")   # CREATE TABLE / INSERT INTO / SELECT
+```
+
+Executed via DuckDB (falls back to sqlite3 if duckdb isn't installed).
+`DROP` / `TRUNCATE` / `DELETE` / `ALTER` are always refused — use the
+DataOps API for explicit, audited writes instead.
+
+## Privacy & security
+
+Everything runs **locally**. TigerDataLab never uploads your data, never
+calls an external API by default, and never executes arbitrary shell
+commands from a dataset. The business-insight engine is fully deterministic
+and rule-based — no LLM key required. An `InsightProvider` interface exists
+for anyone who wants to plug in an optional LLM-backed provider later.
+
+## Project layout
+
+```
+tigerdatalab/
+├── core.py                 # AnalysisResult, analyze(), open(), large()
+├── config.py
+├── exceptions.py
+├── io/loaders.py           # csv/excel/json/parquet/sql/sqlite/duckdb loading
+├── quality/                # types.py, profiler.py, cleaning.py
+├── analytics/               # kpi.py, trends.py, customer.py, product.py, category.py, profitability.py
+├── insights/engine.py       # rule-based insight generation
+├── visualization/charts.py  # chart engine (11 chart types)
+├── dashboard/builder.py     # interactive HTML dashboard
+├── reporting/               # html.py, pdf.py, exporters.py
+├── dataops/asset.py         # update/insert/delete/upsert/merge/rollback/audit
+├── scale/duckdb_engine.py   # lazy large-data aggregation
+└── cli/main.py
+```
+
+## Testing
+
+```bash
+python -m pytest
+python examples/sales_analysis.py
+python examples/dataops_example.py
+python examples/large_data_example.py
+```
+
+31 tests cover CSV/Excel/Parquet/SQL loading, boolean-safe type detection,
+missing-date/no-trend handling, empty/one-column/categorical-only datasets,
+DataOps (insert/update/delete/upsert/rollback/audit), and DuckDB large-data
+aggregation.
+
+## Publishing to PyPI
+
+```bash
+pip install build twine
+python -m build
+twine upload dist/*
+```
+
+## Version
+
+3.0.0 — see `CHANGELOG.md` for the full list of fixes over the 2.2.0 prototype.

tigerdatalab-3.0.4/pyproject.toml

@@ -0,0 +1,47 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tigerdatalab"
+version = "3.0.4"
+description = "Automated Data Analytics + Data Quality + Visualization + BI + DataOps platform, built on pandas/numpy/duckdb/plotly."
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+authors = [{ name = "Abhi" }]
+keywords = ["data-analysis", "business-intelligence", "eda", "dataops", "dashboard", "pandas", "duckdb", "plotly"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering :: Information Analysis",
+]
+dependencies = [
+    "pandas>=1.5",
+    "numpy>=1.23",
+    "openpyxl>=3.1",
+    "plotly>=5.18",
+    "charset-normalizer>=3.0",
+]
+
+[project.optional-dependencies]
+large = ["duckdb>=0.10", "pyarrow>=14.0"]
+pdf = ["reportlab>=4.0"]
+all = ["duckdb>=0.10", "pyarrow>=14.0", "reportlab>=4.0"]
+dev = ["pytest>=7.4", "pytest-cov>=4.1"]
+
+[project.urls]
+Homepage = "https://github.com/abhi15724/tigerdatalab"
+Repository = "https://github.com/abhi15724/tigerdatalab"
+
+[project.scripts]
+tigerdatalab = "tigerdatalab.cli.main:main"
+
+[tool.setuptools.packages.find]
+include = ["tigerdatalab*"]

tigerdatalab-3.0.4/setup.cfg

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

tigerdatalab-3.0.4/tests/test_bugs.py

@@ -0,0 +1,135 @@
+"""Regression tests for the specific bugs the spec calls out by name."""
+import pandas as pd
+import pytest
+
+import tigerdatalab as tdl
+from tigerdatalab.quality.types import detect_dtype, safe_quantile, detect_all_dtypes
+from tigerdatalab.quality.profiler import outlier_report
+from tigerdatalab.exceptions import EmptyDatasetError, UnsupportedFileTypeError
+
+
+def test_summary_attribute_exists(csv_path):
+    result = tdl.analyze(str(csv_path), verbose=False)
+    assert hasattr(result, "summary")
+    assert isinstance(result.summary(), str)
+
+
+def test_boolean_column_never_quantiled(sales_df):
+    # in_stock is a real boolean column in the fixture
+    assert detect_dtype(sales_df["in_stock"]) == "boolean"
+    assert safe_quantile(sales_df["in_stock"], 0.5) is None
+
+    dtypes = detect_all_dtypes(sales_df)
+    report = outlier_report(sales_df, dtypes)
+    assert "in_stock" not in report["by_column"]
+
+
+def test_output_paths_are_paths_not_dicts(csv_path, tmp_path):
+    result = tdl.analyze(str(csv_path), verbose=False)
+    outputs = result.export(tmp_path / "analysis")
+    for key, path in outputs.items():
+        assert hasattr(path, "exists"), f"{key} output should be a Path-like object"
+        assert path.exists()
+
+
+def test_messy_dates_do_not_crash(messy_df, tmp_path):
+    p = tmp_path / "messy.csv"
+    messy_df.to_csv(p, index=False)
+    result = tdl.analyze(str(p), verbose=False)
+    assert result.profile["rows"] >= 1
+
+
+def test_missing_trend_does_not_crash_dashboard(no_date_df, tmp_path):
+    p = tmp_path / "no_date.csv"
+    no_date_df.to_csv(p, index=False)
+    result = tdl.analyze(str(p), verbose=False)
+    out = result.dashboard(tmp_path / "dashboard.html")
+    html = out.read_text()
+    assert "Not enough data" in html
+
+
+def test_multiple_chart_types_present(csv_path):
+    result = tdl.analyze(str(csv_path), verbose=False)
+    keys = {s.key for s in result.visualize()}
+    # more than "only one chart type"
+    assert len({"performance_trend", "category_pie", "product_bar", "correlation_heatmap"} & keys) == 4
+
+
+def test_every_chart_has_explanatory_metadata(csv_path):
+    result = tdl.analyze(str(csv_path), verbose=False)
+    for spec in result.visualize():
+        meta = spec.to_meta()
+        assert meta["title"]
+
+
+def test_empty_dataset_raises_clear_error(tmp_path):
+    p = tmp_path / "empty.csv"
+    pd.DataFrame({"a": [], "b": []}).to_csv(p, index=False)
+    with pytest.raises(EmptyDatasetError):
+        tdl.analyze(str(p), verbose=False)
+
+
+def test_unsupported_extension_raises_clear_error(tmp_path):
+    p = tmp_path / "file.abc"
+    p.write_text("nothing")
+    with pytest.raises(UnsupportedFileTypeError):
+        tdl.analyze(str(p), verbose=False)
+
+
+def test_one_column_numeric_only_dataset(tmp_path):
+    p = tmp_path / "single.csv"
+    pd.DataFrame({"revenue": [1, 2, 3, 4, 5]}).to_csv(p, index=False)
+    result = tdl.analyze(str(p), verbose=False)
+    assert result.kpis().get("total_revenue") == 15
+
+
+def test_camelcase_columns_detected_correctly(tmp_path):
+    # Reproduces: a catalog-style CSV with camelCase headers (mrp,
+    # discountPercent, discountedSellingPrice, name, Category ...) failed
+    # to detect the plain "name" column as a product identifier, so
+    # result.products() incorrectly reported "not available".
+    p = tmp_path / "catalog.csv"
+    p.write_text(
+        "Category,name,mrp,discountPercent,discountedSellingPrice,quantity\n"
+        "Snacks,Choco Bar,100,10,90,5\n"
+        "Snacks,Wafer Pack,80,20,64,10\n"
+        "Beverages,Cola Can,50,5,47.5,20\n"
+    )
+    result = tdl.analyze(str(p), verbose=False)
+    assert result.semantics.get("product") == "name"
+    assert result.products()["available"] is True
+
+
+def test_print_table_runs_without_error(capsys):
+    result = tdl.analyze("tests/data/finance.csv", verbose=False)
+    result.print_table()
+    captured = capsys.readouterr()
+    assert "DATASET OVERVIEW" in captured.out
+    assert "BUSINESS KPIs" in captured.out
+
+
+def test_non_utf8_csv_does_not_crash(tmp_path):
+    # Reproduces: UnicodeDecodeError: 'utf-8' codec can't decode byte 0x92
+    # This happens on real-world CSVs exported from Excel/Windows, which
+    # are commonly cp1252 and contain "smart quote" characters (0x91-0x94).
+    p = tmp_path / "windows_export.csv"
+    with open(p, "wb") as f:
+        f.write("order_id,customer_name,notes,revenue\n".encode("utf-8"))
+        f.write(
+            ("1,O'Brien,Client said " + chr(0x2019) + "great job" + chr(0x2019)
+             + " today,100.0\n").encode("cp1252")
+        )
+        f.write("2,Smith,ok,200.5\n".encode("utf-8"))
+        f.write("3,Lee,fine,150.25\n".encode("utf-8"))
+
+    result = tdl.analyze(str(p), verbose=False)
+    assert result.profile["rows"] == 3
+    assert result.load_meta["encoding"] != "utf-8"
+    assert "\u2019" in result.cleaned_df["notes"].iloc[0]
+
+
+def test_categorical_only_dataset(tmp_path):
+    p = tmp_path / "cat_only.csv"
+    pd.DataFrame({"category": ["A", "B", "A", "C"], "region": ["N", "S", "E", "W"]}).to_csv(p, index=False)
+    result = tdl.analyze(str(p), verbose=False)
+    assert result.profile["rows"] == 4