eda-k 0.1.0__tar.gz

eda_k-0.1.0/MANIFEST.in

@@ -0,0 +1,6 @@
+global-
+include *.txt *.py
+include README.md
+include pyproject.toml
+include requirements.txt
+recursive-include src *.py

eda_k-0.1.0/PKG-INFO

@@ -0,0 +1,137 @@
+Metadata-Version: 2.4
+Name: eda-k
+Version: 0.1.0
+Summary: Automated, local exploratory data analysis: stats, charts, correlations, outliers, a chat assistant, and self-contained HTML reports.
+Author: Kishan Prajapati
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: licence.txt
+Requires-Dist: pandas>=2.0
+Requires-Dist: numpy>=1.24
+Requires-Dist: scipy>=1.10
+Requires-Dist: plotly>=5.20
+Requires-Dist: openpyxl>=3.1
+Requires-Dist: xlrd>=2.0
+Requires-Dist: pyarrow>=14.0
+Provides-Extra: app
+Requires-Dist: streamlit>=1.36; extra == "app"
+Provides-Extra: trend
+Requires-Dist: statsmodels; extra == "trend"
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+# eda-k
+
+Automated, local exploratory data analysis — as a **Python library** you can
+`import`, with an optional Streamlit UI on top.
+
+Runs 100% locally. Your data never leaves your machine, no API key needed.
+
+---
+
+## Install
+
+```bash
+pip install -e .
+```
+
+Want everything in one shot (library + Streamlit app + OLS trendlines)?
+
+```bash
+pip install -e ".[app,trend]"
+```
+
+Or pick extras individually:
+
+Need the bundled Streamlit app too?
+
+```bash
+pip install -e ".[app]"
+```
+
+Need OLS trendlines on scatter plots (`charts.pairwise_scatter_with_trendline`)?
+
+```bash
+pip install -e ".[trend]"
+```
+
+---
+
+## Use it as a library
+
+```python
+import eda_k
+
+result = eda_k.analyze("data.csv")   # path, file-like, or DataFrame all work
+
+print(result)                  # <EDAResult 'data.csv' rows=150 cols=5 ...>
+print(result.summary())        # quick text overview
+print(result.ask("which columns have missing values?"))
+
+result.to_html("report.html")     # self-contained HTML report (charts inline)
+result.to_csv_zip("tables.zip")   # every summary table as CSVs in one ZIP
+```
+
+`result.df` is the loaded `pandas.DataFrame`, and `result.results` is the raw
+dict of every table (`overview`, `missing_summary`, `numeric_summary`,
+`outliers`, `categorical_summary`, `correlation`, `top_correlations`,
+`dtype_table`) if you want to work with the data directly.
+
+### Lower-level access
+
+The original modules are available as submodules, unchanged, for full control:
+
+```python
+from eda_k import eda_engine, charts, chat_assistant, report_builder
+
+df = eda_engine.load_file(open("data.csv", "rb"), "data.csv")
+results = eda_engine.run_full_eda(df)
+fig = charts.histogram(df, "some_column")
+```
+
+---
+
+## Use the Streamlit UI
+
+```bash
+pip install -e ".[app]"
+streamlit run apps/streamlit_app.py
+```
+
+Opens a browser tab with upload, tabs (Overview / Missing / Numeric / Outliers
+/ Categorical / Correlation / Chat / Download), and one-click export of the
+HTML report or a ZIP of CSVs — same as before, just now built on top of the
+installed `eda_k` package instead of loose scripts.
+
+---
+
+## Project layout
+
+```
+eda-k/
+├── pyproject.toml
+├── README.md
+├── requirements.txt          # convenience: pip install -r requirements.txt == pip install -e ".[app]"
+├── src/
+│   └── eda_k/
+│       ├── __init__.py        # public API: analyze(), EDAResult
+│       ├── eda_engine.py       # core analysis (pandas/numpy/scipy, no UI)
+│       ├── charts.py           # Plotly chart builders
+│       ├── chat_assistant.py   # local rule-based Q&A
+│       └── report_builder.py   # self-contained HTML report builder
+└── apps/
+    └── streamlit_app.py        # optional UI, imports from the installed package
+```
+
+## Supported file types
+CSV, TSV, TXT (auto-delimiter-detect), XLSX, XLS, JSON, Parquet.
+
+## Notes / known limits
+- Very large files (millions of rows) will be slower to chart; consider
+  sampling first if you hit performance issues.
+- The "likely datetime column" detector is a heuristic on a small sample —
+  always double check it against the Overview before trusting it blindly.
+- Normality test (Shapiro-Wilk) auto-samples to 5,000 rows for large columns
+  for speed.

eda_k-0.1.0/README.md

@@ -0,0 +1,113 @@
+# eda-k
+
+Automated, local exploratory data analysis — as a **Python library** you can
+`import`, with an optional Streamlit UI on top.
+
+Runs 100% locally. Your data never leaves your machine, no API key needed.
+
+---
+
+## Install
+
+```bash
+pip install -e .
+```
+
+Want everything in one shot (library + Streamlit app + OLS trendlines)?
+
+```bash
+pip install -e ".[app,trend]"
+```
+
+Or pick extras individually:
+
+Need the bundled Streamlit app too?
+
+```bash
+pip install -e ".[app]"
+```
+
+Need OLS trendlines on scatter plots (`charts.pairwise_scatter_with_trendline`)?
+
+```bash
+pip install -e ".[trend]"
+```
+
+---
+
+## Use it as a library
+
+```python
+import eda_k
+
+result = eda_k.analyze("data.csv")   # path, file-like, or DataFrame all work
+
+print(result)                  # <EDAResult 'data.csv' rows=150 cols=5 ...>
+print(result.summary())        # quick text overview
+print(result.ask("which columns have missing values?"))
+
+result.to_html("report.html")     # self-contained HTML report (charts inline)
+result.to_csv_zip("tables.zip")   # every summary table as CSVs in one ZIP
+```
+
+`result.df` is the loaded `pandas.DataFrame`, and `result.results` is the raw
+dict of every table (`overview`, `missing_summary`, `numeric_summary`,
+`outliers`, `categorical_summary`, `correlation`, `top_correlations`,
+`dtype_table`) if you want to work with the data directly.
+
+### Lower-level access
+
+The original modules are available as submodules, unchanged, for full control:
+
+```python
+from eda_k import eda_engine, charts, chat_assistant, report_builder
+
+df = eda_engine.load_file(open("data.csv", "rb"), "data.csv")
+results = eda_engine.run_full_eda(df)
+fig = charts.histogram(df, "some_column")
+```
+
+---
+
+## Use the Streamlit UI
+
+```bash
+pip install -e ".[app]"
+streamlit run apps/streamlit_app.py
+```
+
+Opens a browser tab with upload, tabs (Overview / Missing / Numeric / Outliers
+/ Categorical / Correlation / Chat / Download), and one-click export of the
+HTML report or a ZIP of CSVs — same as before, just now built on top of the
+installed `eda_k` package instead of loose scripts.
+
+---
+
+## Project layout
+
+```
+eda-k/
+├── pyproject.toml
+├── README.md
+├── requirements.txt          # convenience: pip install -r requirements.txt == pip install -e ".[app]"
+├── src/
+│   └── eda_k/
+│       ├── __init__.py        # public API: analyze(), EDAResult
+│       ├── eda_engine.py       # core analysis (pandas/numpy/scipy, no UI)
+│       ├── charts.py           # Plotly chart builders
+│       ├── chat_assistant.py   # local rule-based Q&A
+│       └── report_builder.py   # self-contained HTML report builder
+└── apps/
+    └── streamlit_app.py        # optional UI, imports from the installed package
+```
+
+## Supported file types
+CSV, TSV, TXT (auto-delimiter-detect), XLSX, XLS, JSON, Parquet.
+
+## Notes / known limits
+- Very large files (millions of rows) will be slower to chart; consider
+  sampling first if you hit performance issues.
+- The "likely datetime column" detector is a heuristic on a small sample —
+  always double check it against the Overview before trusting it blindly.
+- Normality test (Shapiro-Wilk) auto-samples to 5,000 rows for large columns
+  for speed.

eda_k-0.1.0/chanfelog.txt

@@ -0,0 +1,6 @@
+change log 
+============
+
+0.1.0 (24/06/2026)
+--------------------
+- Frist Release

eda_k-0.1.0/licence.txt

@@ -0,0 +1,7 @@
+Copyright 2026 kishan prajapati
+
+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.

eda_k-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "eda-k"
+version = "0.1.0"
+description = "Automated, local exploratory data analysis: stats, charts, correlations, outliers, a chat assistant, and self-contained HTML reports."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "Kishan Prajapati" }]
+
+dependencies = [
+    "pandas>=2.0",
+    "numpy>=1.24",
+    "scipy>=1.10",
+    "plotly>=5.20",
+    "openpyxl>=3.1",
+    "xlrd>=2.0",
+    "pyarrow>=14.0",
+]
+
+[project.optional-dependencies]
+# Needed only for the bundled Streamlit UI in apps/streamlit_app.py
+app = ["streamlit>=1.36"]
+# Needed only for charts.pairwise_scatter_with_trendline()
+trend = ["statsmodels"]
+dev = ["pytest"]
+
+[tool.setuptools.packages.find]
+where = ["src"]

eda_k-0.1.0/requirements.txt

@@ -0,0 +1 @@
+-e .[app]

eda_k-0.1.0/setup.cfg

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

eda_k-0.1.0/src/eda_k/__init__.py

@@ -0,0 +1,218 @@
+"""
+eda_k
+=====
+A local, no-API-key automated EDA toolkit.
+
+Quick start
+-----------
+    import eda_k
+
+    result = eda_k.analyze("data.csv")
+    result.summary()                      # quick text summary
+    result.to_html("report.html")         # full self-contained HTML report
+    result.to_csv_zip("tables.zip")       # all summary tables as a ZIP of CSVs
+    result.ask("which columns have missing values?")
+
+Lower-level building blocks (`eda_engine`, `charts`, `chat_assistant`,
+`report_builder`) remain available as submodules for anyone who wants
+finer-grained control, e.g.:
+
+    from eda_k import eda_engine, charts
+    df = eda_engine.load_file(open("data.csv", "rb"), "data.csv")
+    results = eda_engine.run_full_eda(df)
+"""
+
+from __future__ import annotations
+
+import io
+import zipfile
+from pathlib import Path
+from typing import Optional, Union
+
+import pandas as pd
+
+from . import charts, chat_assistant, eda_engine, report_builder
+from .chat_assistant import SUGGESTED_QUESTIONS, answer_question
+from .eda_engine import load_file, run_full_eda
+
+__all__ = [
+    "analyze",
+    "EDAResult",
+    "eda_engine",
+    "charts",
+    "chat_assistant",
+    "report_builder",
+    "load_file",
+    "run_full_eda",
+    "answer_question",
+    "SUGGESTED_QUESTIONS",
+]
+
+__version__ = "0.1.0"
+
+
+class EDAResult:
+    """
+    Convenience wrapper bundling a DataFrame with its EDA results.
+
+    Returned by `eda_k.analyze(...)`. Wraps the same `results` dict
+    produced by `eda_engine.run_full_eda`, plus helpers for reporting,
+    exporting, and Q&A — so you don't need Streamlit to get value out
+    of this library.
+    """
+
+    def __init__(self, df: pd.DataFrame, results: dict, name: str = "dataset"):
+        self.df = df
+        self.results = results
+        self.name = name
+
+    # -- introspection -----------------------------------------------------
+
+    def __repr__(self) -> str:
+        ov = self.results["overview"]
+        return (
+            f"<EDAResult '{self.name}' rows={ov['n_rows']:,} "
+            f"cols={ov['n_cols']:,} missing={ov['missing_pct']}% "
+            f"duplicates={ov['duplicate_rows']:,}>"
+        )
+
+    def summary(self) -> str:
+        """Return a short human-readable text summary."""
+        return answer_question("give me a summary of this dataset", self.df, self.results)
+
+    def ask(self, question: str) -> str:
+        """Ask a natural-language question about the dataset."""
+        return answer_question(question, self.df, self.results)
+
+    # -- figures -------------------------------------------------------------
+
+    def build_figures(self, top_n_cats: int = 10) -> dict:
+        """Build the full set of Plotly figures used in the HTML report."""
+        ov = self.results["overview"]
+        return {
+            "missing_bar": charts.missing_values_bar(self.results["missing_summary"]),
+            "histograms": {c: charts.histogram(self.df, c) for c in ov["numeric_cols"]},
+            "boxplots": {c: charts.boxplot(self.df, c) for c in ov["numeric_cols"]},
+            "categorical_bars": {
+                c: charts.bar_categorical(self.df, c, top_n=top_n_cats)
+                for c in ov["categorical_cols"]
+            },
+            "corr_heatmap": (
+                charts.correlation_heatmap(self.results["correlation"])
+                if not self.results["correlation"].empty
+                else None
+            ),
+        }
+
+    # -- export --------------------------------------------------------------
+
+    def to_html(
+        self,
+        path: Optional[Union[str, Path]] = None,
+        include_advanced_stats: bool = True,
+        top_n_cats: int = 10,
+    ) -> str:
+        """
+        Build the self-contained HTML report.
+
+        If `path` is given, also writes the report to disk.
+        Always returns the HTML string.
+        """
+        figures = self.build_figures(top_n_cats=top_n_cats)
+        html_str = report_builder.build_html_report(
+            self.df,
+            self.results,
+            figures,
+            filename=self.name,
+            include_advanced_stats=include_advanced_stats,
+        )
+        if path is not None:
+            Path(path).write_text(html_str, encoding="utf-8")
+        return html_str
+
+    def to_csv_zip(self, path: Optional[Union[str, Path]] = None) -> bytes:
+        """
+        Build a ZIP archive of every summary table as CSV.
+
+        If `path` is given, also writes the ZIP to disk.
+        Always returns the ZIP bytes.
+        """
+        results = self.results
+        buf = io.BytesIO()
+        with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as zf:
+            zf.writestr("dtype_summary.csv", results["dtype_table"].to_csv(index=False))
+            zf.writestr("missing_values.csv", results["missing_summary"].to_csv(index=False))
+            zf.writestr("numeric_summary.csv", results["numeric_summary"].to_csv(index=False))
+            zf.writestr("outliers.csv", results["outliers"].to_csv(index=False))
+            if not results["correlation"].empty:
+                zf.writestr("correlation_matrix.csv", results["correlation"].to_csv())
+                zf.writestr("top_correlations.csv", results["top_correlations"].to_csv(index=False))
+            for col, info in results["categorical_summary"].items():
+                safe = "".join(ch if ch.isalnum() else "_" for ch in col)
+                zf.writestr(f"categorical_{safe}.csv", info["top_values"].to_csv(index=False))
+        data = buf.getvalue()
+        if path is not None:
+            Path(path).write_bytes(data)
+        return data
+
+
+def analyze(
+    source: Union[str, Path, "io.IOBase", pd.DataFrame],
+    filename: Optional[str] = None,
+    outlier_method: str = "Both",
+    correlation_method: str = "pearson",
+    max_sample_size: int = 5000,
+) -> EDAResult:
+    """
+    Run a full automated EDA pipeline on a file path, file-like object,
+    or an existing DataFrame, and return an `EDAResult`.
+
+    Parameters
+    ----------
+    source : str | Path | file-like | pd.DataFrame
+        A path to a CSV/TSV/TXT/XLSX/XLS/JSON/Parquet file, an open
+        file-like object, or an already-loaded DataFrame.
+    filename : str, optional
+        Used for display/report naming and (when `source` is a path-like
+        string/Path) to infer the file type. Required when `source` is a
+        file-like object without a `.name` attribute and not a DataFrame.
+    outlier_method : {"IQR", "Z-score", "Both"}
+    correlation_method : {"pearson", "spearman", "kendall"}
+    max_sample_size : int
+        Max rows sampled for the Shapiro-Wilk normality test.
+
+    Examples
+    --------
+    >>> result = eda_k.analyze("data.csv")
+    >>> result.summary()
+    >>> result.to_html("report.html")
+    """
+    if isinstance(source, pd.DataFrame):
+        df = source.copy()
+        name = filename or "dataset"
+    else:
+        if isinstance(source, (str, Path)):
+            path = Path(source)
+            name = filename or path.name
+            with open(path, "rb") as f:
+                df = load_file(f, name)
+        else:
+            # file-like object
+            name = filename or getattr(source, "name", None)
+            if not name:
+                raise ValueError(
+                    "filename is required when passing a file-like object "
+                    "without a '.name' attribute"
+                )
+            df = load_file(source, name)
+
+    if df.empty:
+        raise ValueError(f"'{name}' loaded but contains no rows.")
+
+    results = run_full_eda(
+        df,
+        outlier_method=outlier_method,
+        correlation_method=correlation_method,
+        max_sample_size=max_sample_size,
+    )
+    return EDAResult(df, results, name=name)