murthylytics 0.1.0__py3-none-any.whl

murthylytics/io/detect.py

@@ -0,0 +1,125 @@
+"""Automatic detection of encoding, delimiter and datetime columns.
+
+These routines are deliberately dependency-light: they fall back to the standard
+library (``csv.Sniffer``, byte heuristics) when optional packages such as
+``charset-normalizer`` are unavailable, so basic CSV reading works out of the box.
+"""
+
+from __future__ import annotations
+
+import csv
+from pathlib import Path
+from typing import List, Optional
+
+import pandas as pd
+
+from ..core.logging import get_logger
+from ..core.optional import has_module
+
+logger = get_logger(__name__)
+
+_COMMON_DELIMITERS = [",", ";", "\t", "|", ":"]
+
+
+def detect_encoding(path: str, *, sample_bytes: int = 65_536) -> str:
+    """Best-effort text-encoding detection for a file.
+
+    Uses ``charset-normalizer`` when installed, otherwise a BOM + UTF-8 probe,
+    falling back to ``latin-1`` (which can decode any byte stream).
+    """
+    raw = Path(path).read_bytes()[:sample_bytes]
+
+    # Byte-order marks are unambiguous.
+    if raw.startswith(b"\xef\xbb\xbf"):
+        return "utf-8-sig"
+    if raw.startswith((b"\xff\xfe", b"\xfe\xff")):
+        return "utf-16"
+
+    if has_module("charset_normalizer"):
+        from charset_normalizer import from_bytes  # local import
+
+        result = from_bytes(raw).best()
+        if result is not None and result.encoding:
+            logger.debug("charset-normalizer detected encoding=%s", result.encoding)
+            return result.encoding
+
+    # Standard-library fallback: try strict UTF-8, else latin-1.
+    try:
+        raw.decode("utf-8")
+        return "utf-8"
+    except UnicodeDecodeError:
+        logger.debug("Falling back to latin-1 encoding for %s", path)
+        return "latin-1"
+
+
+def detect_delimiter(
+    path: str,
+    *,
+    encoding: str = "utf-8",
+    sample_bytes: int = 32_768,
+) -> str:
+    """Detect the field delimiter of a delimited text file.
+
+    Tries :class:`csv.Sniffer` first, then a frequency heuristic over common
+    delimiters. Defaults to ``,`` if nothing conclusive is found.
+    """
+    with open(path, encoding=encoding, errors="replace") as fh:
+        sample = fh.read(sample_bytes)
+
+    if not sample:
+        return ","
+
+    try:
+        dialect = csv.Sniffer().sniff(sample, delimiters="".join(_COMMON_DELIMITERS))
+        logger.debug("csv.Sniffer detected delimiter=%r", dialect.delimiter)
+        return dialect.delimiter
+    except csv.Error:
+        pass
+
+    # Frequency heuristic on the first non-empty line.
+    first_line = next((ln for ln in sample.splitlines() if ln.strip()), "")
+    counts = {d: first_line.count(d) for d in _COMMON_DELIMITERS}
+    best = max(counts, key=counts.get)
+    if counts[best] == 0:
+        return ","
+    logger.debug("Heuristic detected delimiter=%r (counts=%s)", best, counts)
+    return best
+
+
+def detect_datetime_columns(
+    df: pd.DataFrame,
+    *,
+    sample_rows: int = 1_000,
+    success_ratio: float = 0.9,
+) -> List[str]:
+    """Return object columns that parse cleanly as datetimes.
+
+    A column is considered datetime-like when at least ``success_ratio`` of its
+    non-null sampled values parse without error.
+    """
+    candidates: List[str] = []
+    obj_cols = df.select_dtypes(include=["object", "string"]).columns
+    sample = df.head(sample_rows)
+
+    for col in obj_cols:
+        non_null = sample[col].dropna()
+        if non_null.empty:
+            continue
+        parsed = pd.to_datetime(non_null, errors="coerce", format="mixed")
+        ratio = parsed.notna().mean()
+        if ratio >= success_ratio:
+            candidates.append(col)
+            logger.debug("Column %r looks datetime-like (%.0f%%)", col, ratio * 100)
+    return candidates
+
+
+def coerce_datetimes(df: pd.DataFrame, columns: Optional[List[str]] = None) -> pd.DataFrame:
+    """Convert the given (or auto-detected) columns to datetime dtype in place-ish.
+
+    Returns the same dataframe with the columns converted; parsing errors become
+    ``NaT`` so this never raises on messy data.
+    """
+    cols = columns if columns is not None else detect_datetime_columns(df)
+    for col in cols:
+        df[col] = pd.to_datetime(df[col], errors="coerce", format="mixed")
+    return df

murthylytics/io/optimize.py

@@ -0,0 +1,84 @@
+"""Memory optimisation for pandas dataframes via dtype downcasting."""
+
+from __future__ import annotations
+
+from typing import Dict
+
+import pandas as pd
+
+from ..core.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+def memory_usage_bytes(df: pd.DataFrame) -> int:
+    """Total deep memory usage of ``df`` in bytes."""
+    return int(df.memory_usage(deep=True).sum())
+
+
+def optimize_memory(
+    df: pd.DataFrame,
+    *,
+    categorical_ratio: float = 0.5,
+    copy: bool = True,
+) -> pd.DataFrame:
+    """Downcast numeric columns and convert low-cardinality objects to category.
+
+    Parameters
+    ----------
+    categorical_ratio:
+        Object columns whose unique/row ratio is below this become ``category``.
+    copy:
+        When True (default) the input is left untouched and a new frame returned.
+
+    Returns
+    -------
+    pandas.DataFrame
+        A dtype-optimised dataframe. Values are preserved; only storage changes.
+    """
+    out = df.copy() if copy else df
+    before = memory_usage_bytes(out)
+
+    for col in out.columns:
+        s = out[col]
+        if pd.api.types.is_bool_dtype(s):
+            continue  # already 1 byte; nothing to gain
+        elif pd.api.types.is_integer_dtype(s):
+            out[col] = pd.to_numeric(s, downcast="integer")
+        elif pd.api.types.is_float_dtype(s):
+            out[col] = pd.to_numeric(s, downcast="float")
+        elif pd.api.types.is_object_dtype(s) or pd.api.types.is_string_dtype(s):
+            # Covers both classic ``object`` columns and the pandas>=3 ``str`` dtype.
+            n = len(s)
+            if n and s.nunique(dropna=False) / n < categorical_ratio:
+                out[col] = s.astype("category")
+
+    after = memory_usage_bytes(out)
+    if before:
+        logger.debug(
+            "Memory optimised: %.2f MB -> %.2f MB (%.1f%% saved)",
+            before / 1e6,
+            after / 1e6,
+            100 * (before - after) / before,
+        )
+    return out
+
+
+def memory_report(df: pd.DataFrame) -> Dict[str, float]:
+    """Return a small dict summarising memory footprint (in MB) per dtype family."""
+    usage = df.memory_usage(deep=True)
+    per_dtype: Dict[str, float] = {}
+    for col in df.columns:
+        family = str(df[col].dtype)
+        per_dtype[family] = per_dtype.get(family, 0.0) + float(usage[col]) / 1e6
+    per_dtype["total"] = float(usage.sum()) / 1e6
+    return {k: round(v, 4) for k, v in per_dtype.items()}
+
+
+def estimate_savings(df: pd.DataFrame) -> float:
+    """Return the fraction of memory that :func:`optimize_memory` would save."""
+    before = memory_usage_bytes(df)
+    if not before:
+        return 0.0
+    after = memory_usage_bytes(optimize_memory(df, copy=True))
+    return round((before - after) / before, 4)

murthylytics/io/readers.py

@@ -0,0 +1,160 @@
+"""Smart data readers with automatic detection and memory optimisation.
+
+Each public ``read_*`` function returns a plain :class:`pandas.DataFrame`. The
+facade layer is responsible for installing the result into the active session;
+keeping these functions side-effect-free makes them trivially testable.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Optional
+
+import pandas as pd
+
+from ..core.config import DEFAULT_CONFIG, Config
+from ..core.exceptions import DataLoadError
+from ..core.logging import get_logger
+from ..core.optional import optional_import
+from ..core.types import PathLike
+from .detect import coerce_datetimes, detect_delimiter, detect_encoding
+from .optimize import optimize_memory
+
+logger = get_logger(__name__)
+
+
+def _post_process(
+    df: pd.DataFrame,
+    *,
+    config: Config,
+    parse_dates: bool,
+) -> pd.DataFrame:
+    """Shared post-load steps: datetime coercion + optional memory optimisation."""
+    if parse_dates:
+        df = coerce_datetimes(df)
+    if config.memory_optimize:
+        df = optimize_memory(df, copy=False)
+    return df
+
+
+def read_csv(
+    path: PathLike,
+    *,
+    config: Config = DEFAULT_CONFIG,
+    encoding: Optional[str] = None,
+    delimiter: Optional[str] = None,
+    parse_dates: bool = True,
+    **kwargs: Any,
+) -> pd.DataFrame:
+    """Read a CSV/TSV file, auto-detecting encoding and delimiter.
+
+    Parameters
+    ----------
+    path:
+        Filesystem path to the delimited text file.
+    encoding, delimiter:
+        Override auto-detection when provided.
+    parse_dates:
+        Auto-detect and convert datetime-like string columns.
+    **kwargs:
+        Forwarded to :func:`pandas.read_csv`.
+    """
+    p = Path(path)
+    if not p.exists():
+        raise DataLoadError(f"File not found: {p}")
+
+    enc = encoding or detect_encoding(str(p))
+    sep = delimiter or detect_delimiter(str(p), encoding=enc)
+    logger.info("Reading CSV %s (encoding=%s, delimiter=%r)", p.name, enc, sep)
+
+    try:
+        df = pd.read_csv(p, encoding=enc, sep=sep, **kwargs)
+    except Exception as exc:  # noqa: BLE001 - re-raised as library error
+        raise DataLoadError(f"Failed to read CSV {p}: {exc}") from exc
+
+    return _post_process(df, config=config, parse_dates=parse_dates)
+
+
+def read_excel(
+    path: PathLike,
+    *,
+    config: Config = DEFAULT_CONFIG,
+    sheet_name: Any = 0,
+    parse_dates: bool = True,
+    **kwargs: Any,
+) -> pd.DataFrame:
+    """Read an Excel workbook (requires the ``io`` extra / ``openpyxl``)."""
+    optional_import("openpyxl", extra="io")
+    p = Path(path)
+    if not p.exists():
+        raise DataLoadError(f"File not found: {p}")
+    logger.info("Reading Excel %s (sheet=%s)", p.name, sheet_name)
+    try:
+        df = pd.read_excel(p, sheet_name=sheet_name, **kwargs)
+    except Exception as exc:  # noqa: BLE001
+        raise DataLoadError(f"Failed to read Excel {p}: {exc}") from exc
+    if isinstance(df, dict):  # multiple sheets requested
+        return {k: _post_process(v, config=config, parse_dates=parse_dates) for k, v in df.items()}  # type: ignore[return-value]
+    return _post_process(df, config=config, parse_dates=parse_dates)
+
+
+def read_json(
+    path: PathLike,
+    *,
+    config: Config = DEFAULT_CONFIG,
+    parse_dates: bool = True,
+    **kwargs: Any,
+) -> pd.DataFrame:
+    """Read a JSON file into a dataframe (records or column orientation)."""
+    p = Path(path)
+    if not p.exists():
+        raise DataLoadError(f"File not found: {p}")
+    logger.info("Reading JSON %s", p.name)
+    try:
+        df = pd.read_json(p, **kwargs)
+    except Exception as exc:  # noqa: BLE001
+        raise DataLoadError(f"Failed to read JSON {p}: {exc}") from exc
+    return _post_process(df, config=config, parse_dates=parse_dates)
+
+
+def read_parquet(
+    path: PathLike,
+    *,
+    config: Config = DEFAULT_CONFIG,
+    parse_dates: bool = False,
+    **kwargs: Any,
+) -> pd.DataFrame:
+    """Read a Parquet file (requires the ``io`` extra / ``pyarrow``).
+
+    Datetime coercion defaults to off because Parquet already carries dtypes.
+    """
+    optional_import("pyarrow", extra="io")
+    p = Path(path)
+    if not p.exists():
+        raise DataLoadError(f"File not found: {p}")
+    logger.info("Reading Parquet %s", p.name)
+    try:
+        df = pd.read_parquet(p, **kwargs)
+    except Exception as exc:  # noqa: BLE001
+        raise DataLoadError(f"Failed to read Parquet {p}: {exc}") from exc
+    return _post_process(df, config=config, parse_dates=parse_dates)
+
+
+def read_sql(
+    query: str,
+    con: Any,
+    *,
+    config: Config = DEFAULT_CONFIG,
+    parse_dates: bool = True,
+    **kwargs: Any,
+) -> pd.DataFrame:
+    """Run ``query`` against a SQL connection/engine and return the result.
+
+    ``con`` may be a DBAPI connection or a SQLAlchemy engine/URL string.
+    """
+    logger.info("Reading SQL query")
+    try:
+        df = pd.read_sql(query, con, **kwargs)
+    except Exception as exc:  # noqa: BLE001
+        raise DataLoadError(f"Failed to execute SQL read: {exc}") from exc
+    return _post_process(df, config=config, parse_dates=parse_dates)

murthylytics/modeling/__init__.py

@@ -0,0 +1 @@
+"""Murthylytics modeling module (roadmap — see project README for status)."""

murthylytics/pipeline/__init__.py

@@ -0,0 +1 @@
+"""Murthylytics pipeline module (roadmap — see project README for status)."""

murthylytics/plugins/__init__.py

@@ -0,0 +1 @@
+"""Murthylytics plugins module (roadmap — see project README for status)."""

murthylytics/preprocess/__init__.py

@@ -0,0 +1 @@
+"""Murthylytics preprocess module (roadmap — see project README for status)."""

murthylytics/viz/__init__.py

@@ -0,0 +1 @@
+"""Murthylytics viz module (roadmap — see project README for status)."""

murthylytics-0.1.0.dist-info/METADATA

@@ -0,0 +1,168 @@
+Metadata-Version: 2.4
+Name: murthylytics
+Version: 0.1.0
+Summary: Production-grade, AI-powered machine learning data-analysis and preparation library.
+Project-URL: Homepage, https://github.com/pranavmurthy/murthylytics
+Project-URL: Repository, https://github.com/pranavmurthy/murthylytics
+Project-URL: Issues, https://github.com/pranavmurthy/murthylytics/issues
+Author: Pranav Murthy
+License: MIT
+License-File: LICENSE
+Keywords: autoeda,automl,data-cleaning,data-science,eda,feature-engineering,feature-selection,machine-learning,preprocessing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+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 :: Artificial Intelligence
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Requires-Dist: numpy>=1.23
+Requires-Dist: pandas>=1.5
+Provides-Extra: all
+Requires-Dist: charset-normalizer>=3.0; extra == 'all'
+Requires-Dist: jinja2>=3.1; extra == 'all'
+Requires-Dist: lightgbm>=3.3; extra == 'all'
+Requires-Dist: matplotlib>=3.6; extra == 'all'
+Requires-Dist: openpyxl>=3.1; extra == 'all'
+Requires-Dist: pyarrow>=10.0; extra == 'all'
+Requires-Dist: scikit-learn>=1.1; extra == 'all'
+Requires-Dist: scipy>=1.9; extra == 'all'
+Requires-Dist: seaborn>=0.12; extra == 'all'
+Requires-Dist: sqlalchemy>=2.0; extra == 'all'
+Requires-Dist: xgboost>=1.7; extra == 'all'
+Provides-Extra: dev
+Requires-Dist: black>=23.0; extra == 'dev'
+Requires-Dist: mypy>=1.5; extra == 'dev'
+Requires-Dist: pre-commit>=3.4; extra == 'dev'
+Requires-Dist: pytest-cov>=4.1; extra == 'dev'
+Requires-Dist: pytest>=7.4; extra == 'dev'
+Requires-Dist: ruff>=0.1; extra == 'dev'
+Provides-Extra: io
+Requires-Dist: charset-normalizer>=3.0; extra == 'io'
+Requires-Dist: openpyxl>=3.1; extra == 'io'
+Requires-Dist: pyarrow>=10.0; extra == 'io'
+Requires-Dist: sqlalchemy>=2.0; extra == 'io'
+Provides-Extra: ml
+Requires-Dist: lightgbm>=3.3; extra == 'ml'
+Requires-Dist: xgboost>=1.7; extra == 'ml'
+Provides-Extra: polars
+Requires-Dist: polars>=0.20; extra == 'polars'
+Provides-Extra: report
+Requires-Dist: jinja2>=3.1; extra == 'report'
+Provides-Extra: stats
+Requires-Dist: scikit-learn>=1.1; extra == 'stats'
+Requires-Dist: scipy>=1.9; extra == 'stats'
+Provides-Extra: viz
+Requires-Dist: matplotlib>=3.6; extra == 'viz'
+Requires-Dist: seaborn>=0.12; extra == 'viz'
+Description-Content-Type: text/markdown
+
+# Murthylytics
+
+**Production-grade, AI-powered machine-learning data analysis & preparation for Python.**
+
+Murthylytics turns hundreds of lines of exploratory-data-analysis and preprocessing
+boilerplate into a handful of intuitive commands — while staying transparent,
+configurable and production-quality. Think of it as a next-generation companion to
+pandas, ydata-profiling, Sweetviz and scikit-learn's preprocessing tools, unified
+behind one stateful API.
+
+```python
+import murthylytics as mlt
+
+mlt.read_csv("data.csv")   # auto-detects encoding, delimiter, dtypes, datetimes
+
+mlt.summary()              # compact overview
+mlt.inspect()              # intelligent profiling: roles, targets, leakage, issues
+
+mlt.clean_data()           # roadmap: intelligent cleaning & imputation
+mlt.auto_eda()             # roadmap: HTML / Markdown / PDF / JSON reports
+mlt.preprocess()           # roadmap: task detection + preprocessing pipeline
+mlt.recommend_model()      # roadmap: model recommendations with justification
+```
+
+## Why Murthylytics
+
+- **One stateful facade.** Load a dataset once; every call operates on the active
+  session — no handle passing.
+- **Intelligent by default.** Encoding/delimiter/dtype detection, column-role
+  inference, target detection, class-imbalance and data-leakage checks, all automatic.
+- **Lightweight core, optional power.** Base install is just pandas + numpy. Heavy
+  tooling (plots, XGBoost, SHAP, Parquet…) is lazy-loaded behind extras.
+- **Engineered to last.** `src/` layout, full type hints, SOLID modules, a pure
+  stateless engine under the facade, and a test suite.
+
+## Installation
+
+```bash
+pip install murthylytics            # core (pandas + numpy)
+pip install 'murthylytics[stats]'   # scipy + scikit-learn powered analysis
+pip install 'murthylytics[viz]'     # matplotlib + seaborn plotting
+pip install 'murthylytics[all]'     # everything
+```
+
+> Develop locally: `pip install -e '.[dev,stats]'`
+
+## Quick start
+
+```python
+import murthylytics as mlt
+
+mlt.read_csv("titanic.csv")
+
+mlt.shape()          # {'rows': 891, 'columns': 12}
+mlt.missing()        # per-column missing counts & %
+report = mlt.inspect()
+print(report)                    # human-readable summary
+print(report.recommendations)    # actionable next steps
+report.to_dict()                 # JSON-serialisable
+```
+
+## Feature status
+
+| Area | API | Status |
+|------|-----|--------|
+| Data I/O (CSV/Excel/JSON/Parquet/SQL) | `read_*` | ✅ available |
+| Exploration | `show/top/bottom/shape/columns/summary/describe/info/types/missing/duplicates/memory` | ✅ available |
+| Intelligent inspection | `inspect` | ✅ available |
+| Intelligent cleaning | `clean_data` | 🚧 roadmap (iteration 2) |
+| Visualization | `cleaned_pyplot` | 🚧 roadmap (iteration 3) |
+| AutoEDA reports | `auto_eda` | 🚧 roadmap (iteration 4) |
+| Preprocessing | `preprocess` | 🚧 roadmap (iteration 5) |
+| Feature engineering / selection | `engineer_features` / `select_features` | 🚧 roadmap (iteration 6) |
+| Model recommendation | `recommend_model` | 🚧 roadmap (iteration 7) |
+| Pipeline export | `export_pipeline` | 🚧 roadmap (iteration 8) |
+| Plugins (malware, finance, …) | `use_plugin` | 🚧 roadmap (iteration 9) |
+
+The roadmap functions are already part of the public surface with stable
+signatures; calling one today raises a clear `NotImplementedError` pointing at the
+iteration that delivers it.
+
+## Architecture
+
+```
+murthylytics/
+├── core/          config · session/context · logging · exceptions · types
+├── io/            smart readers · encoding/delimiter/dtype detection · memory opt
+├── exploration/   display helpers · intelligent inspection
+├── cleaning/      (roadmap) duplicates · imputation · outliers · text fixes
+├── viz/           (roadmap) auto-plot dispatcher
+├── eda/           (roadmap) HTML/MD/PDF/JSON reports
+├── preprocess/    (roadmap) task detection · scaling · encoding · pipelines
+├── features/      (roadmap) engineering · selection
+├── modeling/      (roadmap) model recommendation
+├── pipeline/      (roadmap) save/load/export
+└── plugins/       (roadmap) domain plugins
+```
+
+All mutable state lives in a single `Session`; the engine modules are pure
+functions, which keeps them independently testable and reusable.
+
+## License
+
+MIT © Pranav Murthy

murthylytics-0.1.0.dist-info/RECORD

@@ -0,0 +1,29 @@
+murthylytics/__init__.py,sha256=qQEfnT-aEpEF_-yU77tSoDknQSN08HX-KS0sLGaBOEU,8715
+murthylytics/_version.py,sha256=Y_2bqYDoRNq0PnhUrLbcwDTa_O-tiNwjoBWEyVHCbyk,97
+murthylytics/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+murthylytics/cleaning/__init__.py,sha256=uiCJNBp5Gi4hCkRnqihutGY-TOwoaCRHs4BTYkESR2Q,80
+murthylytics/core/__init__.py,sha256=3rsJODb7lgPBMUppzAnPnzwLrMc9e97tN39nwdBWh9c,1034
+murthylytics/core/config.py,sha256=GO6US631lZCLjnw_DsQ9b_SITCKmZE6_d4pworuNvrk,3410
+murthylytics/core/context.py,sha256=vy0AUM57G6yS01sq2tjVI_56PZ5mhOhSdMY8JqFT4vE,4033
+murthylytics/core/exceptions.py,sha256=MGeJ_x4-e0UilBNZT6e90zM1D8n6urvCKIPS5XdFL-g,1721
+murthylytics/core/logging.py,sha256=6lTS3C8X00ofAxPwqOVRwJrLMgif53CgLyPvkebUF68,2436
+murthylytics/core/optional.py,sha256=1xXOzGVO5tIh_ErYgGeT10CFd-ep_NyS_qn4TijmLyY,1053
+murthylytics/core/types.py,sha256=3hDVsmfyTnM38-qo3SJ7DBkW_AsG_YhGC91423cScpc,1265
+murthylytics/eda/__init__.py,sha256=B-eWo5TFQuiIsFfg-JrHsQq-L5PtAhcICK4uRgXK9Z0,75
+murthylytics/exploration/__init__.py,sha256=Yeoh1C-y8NwpBFESuULpf2q4JnGn6caGerMRqZano1A,577
+murthylytics/exploration/display.py,sha256=mmz35Baul1X7ivPuJ697uwquY1KidvHLoiI9rI9tRn4,3288
+murthylytics/exploration/inspect.py,sha256=3n_E3EnoH_VMVItQs83gkZOi_KMm-y1FnthYJkFvd1k,12980
+murthylytics/features/__init__.py,sha256=L7-4zxRwVQhTSRdde-OPNaK8chqSiH-dDws9_Y16eu8,80
+murthylytics/io/__init__.py,sha256=-Kd4tc3dRep4mYPWz4FGtaj5f-WJrz_xH_1FllUW5ls,696
+murthylytics/io/detect.py,sha256=WjSKTHaAEgRPp71AUxb_ue2V1Lo0QdQi5DvA5H44LBo,4151
+murthylytics/io/optimize.py,sha256=qPh4t6q4VcCvsuxh6BYW-yskZgJtk1e7C0AkpFfOHnk,2739
+murthylytics/io/readers.py,sha256=wjsrEj_cPyNi_xTBc3HmU7g2mpiqPmKtwMZfzI4OI4I,5115
+murthylytics/modeling/__init__.py,sha256=3BFFE78lOU3Jd7aWulae7yOAf983lLElmRjXdYsI1gQ,80
+murthylytics/pipeline/__init__.py,sha256=UPTr4p3SCa-rdE4tpSQFY7y9utpE6izSVXcO34jyofE,80
+murthylytics/plugins/__init__.py,sha256=gvoGZiplIS_5d_C60QZ8UzLnagttzCZqDYQB9Ou6C-E,79
+murthylytics/preprocess/__init__.py,sha256=6MNf_fVnFDF8amNI8i-a7pFbbITqDx57XmuU_iz2OGE,82
+murthylytics/viz/__init__.py,sha256=fQbkkGKmXMZh1iNKnSUTfCG9v9CaUGPGSSwcqsPLY-A,75
+murthylytics-0.1.0.dist-info/METADATA,sha256=0sYSh-4CX1l0ZatcpWR19y9GLBwkjqUSSkuBDGH9Exg,7075
+murthylytics-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+murthylytics-0.1.0.dist-info/licenses/LICENSE,sha256=uXZ_CuyPB27fqGyOVYgix7vgrdrSRYJX6BZH7afbB64,1070
+murthylytics-0.1.0.dist-info/RECORD,,

murthylytics-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

murthylytics-0.1.0.dist-info/licenses/LICENSE

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