nseindiapy 0.1.0__tar.gz

nseindiapy-0.1.0/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.3
+Name: nseindiapy
+Version: 0.1.0
+Summary: Python client for NSE Indices (niftyindices.com) — historical data, live market data, daily snapshots, reports, and holiday calendar.
+Keywords: nse,nifty,india,stock market,indices,finance
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Office/Business :: Financial
+Requires-Dist: requests>=2.32
+Requires-Dist: polars>=1.0
+Requires-Dist: python-dateutil>=2.9
+Requires-Dist: beautifulsoup4>=4.12
+Requires-Dist: playwright>=1.40 ; extra == 'playwright'
+Requires-Python: >=3.11
+Project-URL: Homepage, https://skamalj.github.io/nseindiapy/
+Project-URL: Repository, https://github.com/skamalj/nseindiapy
+Project-URL: Documentation, https://skamalj.github.io/nseindiapy/
+Provides-Extra: playwright
+Description-Content-Type: text/markdown
+
+# nseindiapy
+
+Python client for **NSE Indices** ([niftyindices.com](https://www.niftyindices.com)) — historical OHLC, TRI, P/E-P/B, India VIX, live index snapshot, daily snapshots, monthly reports, and the trading holiday calendar. All tabular data returned as [Polars](https://pola.rs/) DataFrames.
+
+📖 **[Full documentation](https://skamalj.github.io/nseindiapy/)**
+
+## Installation
+
+```bash
+pip install nseindiapy
+# or
+uv add nseindiapy
+```
+
+## Quick Start
+
+```python
+from datetime import date
+from nseindiapy import NiftyIndicesClient
+
+client = NiftyIndicesClient()
+
+# Historical OHLC — auto-paginates for ranges > 365 days
+df = client.historical.price_history("NIFTY 50", date(2024, 1, 1), date(2024, 12, 31))
+
+# Total Return Index
+tri = client.historical.tri_history("NIFTY 50", date(2024, 1, 1), date(2024, 12, 31))
+
+# P/E, P/B, Dividend Yield
+pepb = client.historical.pepb_history("NIFTY 50", date(2024, 1, 1), date(2024, 12, 31))
+
+# India VIX (from daily snapshot CSV)
+vix = client.historical.vix_history(date(2024, 1, 1), date(2024, 12, 31))
+
+# Live indices (131 indices, CDN, no auth)
+live = client.live.live_indices()
+
+# Daily closing snapshot (all indices)
+snap = client.reports.daily_snapshot(date.today())
+
+# Holiday calendar
+holidays = client.holidays.get_holidays(2026)
+trading  = client.holidays.trading_days(date(2026, 1, 1), date(2026, 3, 31))
+```
+
+## Features
+
+- **Single entry point** — `NiftyIndicesClient` with four sub-modules
+- **Auto-pagination** — 365-day API limit handled transparently
+- **Session seeding** — ASP.NET cookie seeded automatically; no manual setup needed
+- **Polars DataFrames** — typed columns, `pl.Date` dates, `pl.Float64` numerics
+- **No API key** — all endpoints are public
+
+## Links
+
+- [Documentation](https://skamalj.github.io/nseindiapy/)
+- [PyPI](https://pypi.org/project/nseindiapy/)
+- [GitHub](https://github.com/skamalj/nseindiapy)

nseindiapy-0.1.0/README.md

@@ -0,0 +1,58 @@
+# nseindiapy
+
+Python client for **NSE Indices** ([niftyindices.com](https://www.niftyindices.com)) — historical OHLC, TRI, P/E-P/B, India VIX, live index snapshot, daily snapshots, monthly reports, and the trading holiday calendar. All tabular data returned as [Polars](https://pola.rs/) DataFrames.
+
+📖 **[Full documentation](https://skamalj.github.io/nseindiapy/)**
+
+## Installation
+
+```bash
+pip install nseindiapy
+# or
+uv add nseindiapy
+```
+
+## Quick Start
+
+```python
+from datetime import date
+from nseindiapy import NiftyIndicesClient
+
+client = NiftyIndicesClient()
+
+# Historical OHLC — auto-paginates for ranges > 365 days
+df = client.historical.price_history("NIFTY 50", date(2024, 1, 1), date(2024, 12, 31))
+
+# Total Return Index
+tri = client.historical.tri_history("NIFTY 50", date(2024, 1, 1), date(2024, 12, 31))
+
+# P/E, P/B, Dividend Yield
+pepb = client.historical.pepb_history("NIFTY 50", date(2024, 1, 1), date(2024, 12, 31))
+
+# India VIX (from daily snapshot CSV)
+vix = client.historical.vix_history(date(2024, 1, 1), date(2024, 12, 31))
+
+# Live indices (131 indices, CDN, no auth)
+live = client.live.live_indices()
+
+# Daily closing snapshot (all indices)
+snap = client.reports.daily_snapshot(date.today())
+
+# Holiday calendar
+holidays = client.holidays.get_holidays(2026)
+trading  = client.holidays.trading_days(date(2026, 1, 1), date(2026, 3, 31))
+```
+
+## Features
+
+- **Single entry point** — `NiftyIndicesClient` with four sub-modules
+- **Auto-pagination** — 365-day API limit handled transparently
+- **Session seeding** — ASP.NET cookie seeded automatically; no manual setup needed
+- **Polars DataFrames** — typed columns, `pl.Date` dates, `pl.Float64` numerics
+- **No API key** — all endpoints are public
+
+## Links
+
+- [Documentation](https://skamalj.github.io/nseindiapy/)
+- [PyPI](https://pypi.org/project/nseindiapy/)
+- [GitHub](https://github.com/skamalj/nseindiapy)

nseindiapy-0.1.0/pyproject.toml

@@ -0,0 +1,43 @@
+[project]
+name = "nseindiapy"
+version = "0.1.0"
+description = "Python client for NSE Indices (niftyindices.com) — historical data, live market data, daily snapshots, reports, and holiday calendar."
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "MIT" }
+keywords = ["nse", "nifty", "india", "stock market", "indices", "finance"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Financial and Insurance Industry",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Office/Business :: Financial",
+]
+dependencies = [
+    "requests>=2.32",
+    "polars>=1.0",
+    "python-dateutil>=2.9",
+    "beautifulsoup4>=4.12",
+]
+
+[project.optional-dependencies]
+playwright = ["playwright>=1.40"]
+
+[project.urls]
+Homepage = "https://skamalj.github.io/nseindiapy/"
+Repository = "https://github.com/skamalj/nseindiapy"
+Documentation = "https://skamalj.github.io/nseindiapy/"
+
+[build-system]
+requires = ["uv_build>=0.11.15,<0.12.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "mkdocs-material>=9.5",
+    "mkdocstrings[python]>=0.25",
+]

nseindiapy-0.1.0/src/nseindiapy/__init__.py

@@ -0,0 +1,14 @@
+"""nseindia — Python client for NSE Indices (niftyindices.com)."""
+from .client import NiftyIndicesClient
+from .historical import HistoricalData
+from .holidays import Holidays
+from .live import LiveMarket
+from .reports import Reports
+
+__all__ = [
+    "NiftyIndicesClient",
+    "HistoricalData",
+    "LiveMarket",
+    "Reports",
+    "Holidays",
+]

nseindiapy-0.1.0/src/nseindiapy/_http.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+import requests
+
+BASE_URL = "https://www.niftyindices.com"
+BLOB_URL = "https://iislliveblob.niftyindices.com"
+
+# X-Requested-With is the jQuery AJAX marker required by ASP.NET WebForms.
+# Without it the POST endpoints may be blocked at WAF/proxy level.
+_HEADERS = {
+    "Content-Type": "application/json; charset=utf-8",
+    "X-Requested-With": "XMLHttpRequest",
+    "Accept": "application/json, text/javascript, */*; q=0.01",
+    "Referer": "https://www.niftyindices.com/reports/historical-data",
+    "Origin": "https://www.niftyindices.com",
+    "User-Agent": (
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+        "AppleWebKit/537.36 (KHTML, like Gecko) "
+        "Chrome/125.0.0.0 Safari/537.36"
+    ),
+}
+
+_SEED_URL = BASE_URL + "/reports/historical-data"
+
+
+def make_session(seed: bool = True) -> requests.Session:
+    """Create a requests.Session pre-configured for niftyindices.com.
+
+    Args:
+        seed: If ``True`` (default), performs a GET to the historical-data page
+              to establish an ASP.NET session cookie before any POST calls.
+              This bypasses proxy-level blocks that check for a valid session.
+    """
+    session = requests.Session()
+    session.headers.update(_HEADERS)
+    if seed:
+        try:
+            session.get(_SEED_URL, timeout=20)
+        except Exception:
+            pass  # network errors handled at call site
+    return session

nseindiapy-0.1.0/src/nseindiapy/_nse_session.py

@@ -0,0 +1,60 @@
+"""NSE India session helper — establishes the cookie session required by nseindia.com APIs."""
+from __future__ import annotations
+
+import time
+import requests
+
+_NSE_HOME = "https://www.nseindia.com"
+_NSE_VIX_PAGE = "https://www.nseindia.com/market-data/india-vix"
+
+_HEADERS = {
+    "User-Agent": (
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+        "AppleWebKit/537.36 (KHTML, like Gecko) "
+        "Chrome/124.0.0.0 Safari/537.36"
+    ),
+    "Accept": (
+        "text/html,application/xhtml+xml,application/xml;q=0.9,"
+        "image/avif,image/webp,image/apng,*/*;q=0.8"
+    ),
+    "Accept-Language": "en-US,en;q=0.9",
+    "Accept-Encoding": "gzip, deflate, br",
+    "Connection": "keep-alive",
+    "Upgrade-Insecure-Requests": "1",
+}
+
+_API_HEADERS = {
+    "Accept": "application/json, text/plain, */*",
+    "Referer": _NSE_VIX_PAGE,
+    "X-Requested-With": "XMLHttpRequest",
+}
+
+
+def make_nse_session() -> requests.Session:
+    """Return a requests.Session primed with NSE India cookies.
+
+    NSE India gates its JSON APIs behind a session cookie. This function:
+    1. Visits the homepage to seed the initial cookie
+    2. Visits the India VIX page to establish the correct Referer context
+    3. Returns the session with API-specific headers set
+
+    Note: NSE India uses JavaScript-based bot detection. If the session cannot
+    be established (e.g. 503 from a restricted network), the VIX API will raise
+    an ``HTTPError``. In that case the data is unavailable from this environment.
+    """
+    session = requests.Session()
+    session.headers.update(_HEADERS)
+
+    try:
+        # Step 1: seed cookies from homepage
+        session.get(_NSE_HOME, timeout=20)
+        time.sleep(0.5)
+        # Step 2: visit VIX page for Referer context
+        session.get(_NSE_VIX_PAGE, timeout=20)
+        time.sleep(0.3)
+    except Exception:
+        pass  # network issues handled at call site
+
+    # Switch to JSON-API headers for subsequent API calls
+    session.headers.update(_API_HEADERS)
+    return session

nseindiapy-0.1.0/src/nseindiapy/_utils.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+import json
+from datetime import date, timedelta
+
+import requests
+from dateutil.relativedelta import relativedelta
+
+
+def fmt_date(d: date) -> str:
+    return d.strftime("%d %b %Y")
+
+
+def parse_response(resp: requests.Response) -> list[dict]:
+    outer = resp.json()
+    inner = outer.get("d", "[]")
+    if not isinstance(inner, str):
+        return inner
+    if inner.lower() in ("false", "[]", ""):
+        return []
+    return json.loads(inner)
+
+
+def date_chunks(start: date, end: date, months: int = 12):
+    current = start
+    while current < end:
+        chunk_end = min(current + relativedelta(months=months) - timedelta(days=1), end)
+        yield current, chunk_end
+        current = chunk_end + timedelta(days=1)

nseindiapy-0.1.0/src/nseindiapy/client.py

@@ -0,0 +1,75 @@
+"""Top-level client for niftyindices.com."""
+from __future__ import annotations
+
+from ._http import make_session
+from .historical import HistoricalData
+from .holidays import Holidays
+from .live import LiveMarket
+from .reports import Reports
+
+
+class NiftyIndicesClient:
+    """Unified client for niftyindices.com data.
+
+    All network calls share a single ``requests.Session`` with the required
+    headers pre-configured.
+
+    Sub-modules:
+        - ``client.historical`` — price OHLC, TRI, P/E-P/B, India VIX (via NSE India),
+          index type/category/name discovery
+        - ``client.live``       — live index snapshot (CDN, no auth required)
+        - ``client.reports``    — daily snapshots CSV, monthly PDFs/ZIPs, static resources
+        - ``client.holidays``   — holiday calendar (HTML scrape), trading day utilities
+
+    Example::
+
+        from datetime import date
+        from nseindia import NiftyIndicesClient
+
+        client = NiftyIndicesClient()
+
+        # Historical OHLC (auto-paginates > 365 days)
+        df = client.historical.price_history("NIFTY 50", date(2024, 1, 1), date(2024, 12, 31))
+
+        # TRI and P/E-P/B
+        tri  = client.historical.tri_history("NIFTY 50", date(2024, 1, 1), date(2024, 12, 31))
+        pepb = client.historical.pepb_history("NIFTY 50", date(2024, 1, 1), date(2024, 12, 31))
+
+        # India VIX (fetched from NSE India, session cookie handled automatically)
+        vix = client.historical.vix_history(date(2024, 1, 1), date(2024, 12, 31))
+
+        # Index discovery
+        types = client.historical.list_index_types()
+        cats  = client.historical.list_sub_categories("Equity")
+        names = client.historical.list_indices("Broad Market Indices")
+
+        # Live index snapshot (CDN, ~15-30s refresh during market hours)
+        live = client.live.live_indices()
+
+        # Daily closing CSV
+        snap = client.reports.daily_snapshot(date.today())
+
+        # Monthly reports
+        client.reports.download_monthly(2026, 5, dest_dir="./data")
+
+        # Holiday calendar
+        holidays = client.holidays.get_holidays(2026)
+        trading  = client.holidays.trading_days(date(2026, 1, 1), date(2026, 3, 31))
+    """
+
+    def __init__(self) -> None:
+        self._session = make_session()
+        self.historical = HistoricalData(self._session)
+        self.live = LiveMarket(self._session)
+        self.reports = Reports(self._session)
+        self.holidays = Holidays(self._session)
+
+    def close(self) -> None:
+        """Close the underlying HTTP session."""
+        self._session.close()
+
+    def __enter__(self) -> "NiftyIndicesClient":
+        return self
+
+    def __exit__(self, *_: object) -> None:
+        self.close()

nseindiapy-0.1.0/src/nseindiapy/historical.py

@@ -0,0 +1,299 @@
+"""Historical index data — price OHLC, TRI, P/E-P/B, India VIX."""
+from __future__ import annotations
+
+import io
+import time
+from datetime import date, timedelta
+
+import polars as pl
+import requests
+
+from ._http import BASE_URL, BLOB_URL
+from ._utils import date_chunks, fmt_date, parse_response
+
+_ENDPOINT = BASE_URL + "/Backpage.aspx/{method}"
+_SNAPSHOT_URL = BASE_URL + "/Daily_Snapshot/ind_close_all_{date}.csv"
+
+
+class HistoricalData:
+    def __init__(self, session: requests.Session) -> None:
+        self._s = session
+
+    # ------------------------------------------------------------------
+    # Metadata
+    # ------------------------------------------------------------------
+
+    def get_index_mapping(self) -> list[dict]:
+        """Fetch the index name mapping table from the CDN.
+
+        The file is served with a UTF-8 BOM — decoded automatically.
+        """
+        resp = self._s.get(
+            f"{BLOB_URL}/assets/json/IndexMapping.json", timeout=30
+        )
+        resp.raise_for_status()
+        import json
+        # CDN serves the file with a UTF-8 BOM (EF BB BF prefix)
+        text = resp.content.decode("utf-8-sig")
+        return json.loads(text)
+
+    def list_index_types(self) -> list[str]:
+        """Return top-level index types: Equity, Fixed Income, Multi Asset."""
+        resp = self._s.post(
+            _ENDPOINT.format(method="gethistoricaltypedata1"),
+            json={"cinfo": {}},
+            timeout=30,
+        )
+        resp.raise_for_status()
+        return [r["indextype"] for r in parse_response(resp)]
+
+    def list_sub_categories(
+        self,
+        index_type: str = "Equity",
+        section: str = "Historical Index Data",
+    ) -> list[str]:
+        """List sub-categories for a given index type and section.
+
+        Args:
+            index_type: One of ``"Equity"``, ``"Fixed Income"``, ``"Multi Asset"``.
+            section: ``"Historical Index Data"`` or ``"Total Returns Index Values"``.
+        """
+        resp = self._s.post(
+            _ENDPOINT.format(method="gethistoricaltypeSubindexdata"),
+            json={"cinfo": {"indextype": index_type, "indexgroup": section}},
+            timeout=30,
+        )
+        resp.raise_for_status()
+        return [r["indextype"] for r in parse_response(resp)]
+
+    def list_indices(
+        self,
+        sub_category: str,
+        section: str = "Historical Index Data",
+    ) -> list[str]:
+        """List index names within a sub-category."""
+        resp = self._s.post(
+            _ENDPOINT.format(method="gethistoricaltypeindexdata"),
+            json={"cinfo": {"indextype": sub_category, "indexgroup": section}},
+            timeout=30,
+        )
+        resp.raise_for_status()
+        return [r["indextype"] for r in parse_response(resp)]
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _post_data(
+        self,
+        method: str,
+        index_name: str,
+        start: date,
+        end: date,
+    ) -> list[dict]:
+        payload = {
+            "cinfo": (
+                f"{{'name':'{index_name}',"
+                f"'startDate':'{fmt_date(start)}',"
+                f"'endDate':'{fmt_date(end)}',"
+                f"'indexName':'{index_name}'}}"
+            )
+        }
+        resp = self._s.post(
+            _ENDPOINT.format(method=method), json=payload, timeout=30
+        )
+        resp.raise_for_status()
+        return parse_response(resp)
+
+    def _paginated(
+        self,
+        method: str,
+        index_name: str,
+        start: date,
+        end: date,
+        delay: float = 0.5,
+    ) -> list[dict]:
+        rows: list[dict] = []
+        for chunk_start, chunk_end in date_chunks(start, end, months=12):
+            rows.extend(self._post_data(method, index_name, chunk_start, chunk_end))
+            if chunk_end < end:
+                time.sleep(delay)
+        return rows
+
+    # ------------------------------------------------------------------
+    # Public data methods
+    # ------------------------------------------------------------------
+
+    def price_history(
+        self, index_name: str, start: date, end: date
+    ) -> pl.DataFrame:
+        """Daily OHLC (Price Return Index) for any NSE index.
+
+        Paginates automatically for date ranges > 365 days.
+        Available from 1990. Date format is handled internally.
+        """
+        rows = self._paginated(
+            "getHistoricaldatatabletoString", index_name.upper(), start, end
+        )
+        if not rows:
+            return pl.DataFrame(schema={
+                "index_name": pl.Utf8, "date": pl.Date,
+                "open": pl.Float64, "high": pl.Float64,
+                "low": pl.Float64, "close": pl.Float64,
+            })
+        df = pl.DataFrame(rows)
+        # Normalise whichever index-name field the API returns
+        for src in ("INDEX_NAME", "Index Name"):
+            if src in df.columns and "index_name" not in df.columns:
+                df = df.rename({src: "index_name"})
+        return (
+            df.rename({
+                "HistoricalDate": "date",
+                "OPEN": "open",
+                "HIGH": "high",
+                "LOW": "low",
+                "CLOSE": "close",
+            })
+            .with_columns([
+                pl.col("date").str.to_date("%d %b %Y"),
+                pl.col("open").cast(pl.Float64),
+                pl.col("high").cast(pl.Float64),
+                pl.col("low").cast(pl.Float64),
+                pl.col("close").cast(pl.Float64),
+            ])
+            .select(["index_name", "date", "open", "high", "low", "close"])
+            .sort("date")
+        )
+
+    def tri_history(
+        self, index_name: str, start: date, end: date
+    ) -> pl.DataFrame:
+        """Daily Total Return Index (TRI) values.
+
+        Gross TRI includes dividends reinvested. Net TRI (ntr) applies
+        withholding tax and is only available for NIFTY 50, NIFTY MIDCAP 50,
+        and NIFTY 500. Available from 1995.
+        """
+        rows = self._paginated(
+            "getTotalReturnIndexString", index_name.upper(), start, end
+        )
+        if not rows:
+            return pl.DataFrame(schema={
+                "index_name": pl.Utf8, "date": pl.Date,
+                "tri": pl.Float64, "ntr": pl.Float64,
+            })
+        df = pl.DataFrame(rows)
+        rename_map: dict[str, str] = {}
+        for src, dst in [
+            ("Index Name", "index_name"),
+            ("Date", "date"),
+            ("TotalReturnsIndex", "tri"),
+            ("NTR_Value", "ntr"),
+        ]:
+            if src in df.columns:
+                rename_map[src] = dst
+        df = df.rename(rename_map)
+        casts = [pl.col("date").str.to_date("%d %b %Y"), pl.col("tri").cast(pl.Float64)]
+        if "ntr" in df.columns:
+            casts.append(
+                pl.when(pl.col("ntr").str.strip_chars() == "")
+                .then(pl.lit(None))
+                .otherwise(pl.col("ntr"))
+                .cast(pl.Float64)
+                .alias("ntr")
+            )
+        keep = [c for c in ["index_name", "date", "tri", "ntr"] if c in df.columns]
+        return df.with_columns(casts).select(keep).sort("date")
+
+    def pepb_history(
+        self, index_name: str, start: date, end: date
+    ) -> pl.DataFrame:
+        """Daily P/E, P/B and Dividend Yield ratios. Available from 1996."""
+        rows = self._paginated(
+            "getpepbHistoricaldataDBtoString", index_name.upper(), start, end
+        )
+        if not rows:
+            return pl.DataFrame(schema={
+                "index_name": pl.Utf8, "date": pl.Date,
+                "pe": pl.Float64, "pb": pl.Float64, "div_yield": pl.Float64,
+            })
+        df = pl.DataFrame(rows)
+        return (
+            df.rename({k: v for k, v in {
+                "Index Name": "index_name",
+                "DATE": "date",
+                "divYield": "div_yield",
+            }.items() if k in df.columns})
+            .with_columns([
+                pl.col("date").str.to_date("%d %b %Y"),
+                pl.col("pe").cast(pl.Float64),
+                pl.col("pb").cast(pl.Float64),
+                pl.col("div_yield").cast(pl.Float64),
+            ])
+            .select(["index_name", "date", "pe", "pb", "div_yield"])
+            .sort("date")
+        )
+
+    def vix_history(self, start: date, end: date) -> pl.DataFrame:
+        """Daily OHLC for India VIX, extracted from niftyindices.com daily snapshot CSVs.
+
+        The original ``Backpage.aspx/BindHistoricalIndiaVixData`` endpoint was
+        decommissioned. The Daily Snapshot CSV already contains India VIX as a
+        named row — no NSE India session or Playwright needed.
+
+        Verified live from ``ind_close_all_05062026.csv``::
+
+            India VIX,05-06-2026,15.885,16.37,13.46,15.79,-0.1,-.61,-,-,-,-,-
+
+        Columns returned: ``date``, ``open``, ``high``, ``low``, ``close``,
+        ``points_change``, ``change_pct``.
+
+        Non-trading days (weekends / holidays) are skipped automatically —
+        those dates have no CSV file (HTTP 404).
+        """
+        rows: list[dict] = []
+        dt = start
+        while dt <= end:
+            url = _SNAPSHOT_URL.format(date=dt.strftime("%d%m%Y"))
+            try:
+                resp = self._s.get(url, timeout=15)
+                if resp.status_code == 404:
+                    dt += timedelta(days=1)
+                    continue
+                resp.raise_for_status()
+                # Parse CSV; find "India VIX" row
+                df_snap = pl.read_csv(
+                    io.BytesIO(resp.content),
+                    encoding="utf8-lossy",
+                    infer_schema_length=0,
+                )
+                df_snap = df_snap.rename({c: c.strip() for c in df_snap.columns})
+                vix_row = df_snap.filter(
+                    pl.col("Index Name").str.strip_chars() == "India VIX"
+                )
+                if not vix_row.is_empty():
+                    r = vix_row.row(0, named=True)
+                    rows.append({
+                        "date": dt,
+                        "open":         float(r.get("Open Index Value", "nan").replace(",", "") or "nan"),
+                        "high":         float(r.get("High Index Value", "nan").replace(",", "") or "nan"),
+                        "low":          float(r.get("Low Index Value", "nan").replace(",", "") or "nan"),
+                        "close":        float(r.get("Closing Index Value", "nan").replace(",", "") or "nan"),
+                        "points_change": float((r.get("Points Change") or "nan").replace(",", "") or "nan"),
+                        "change_pct":   float((r.get("Change(%)") or "nan").replace(",", "") or "nan"),
+                    })
+            except Exception:
+                pass
+            dt += timedelta(days=1)
+
+        if not rows:
+            return pl.DataFrame(schema={
+                "date": pl.Date,
+                "open": pl.Float64, "high": pl.Float64,
+                "low": pl.Float64, "close": pl.Float64,
+                "points_change": pl.Float64, "change_pct": pl.Float64,
+            })
+
+        return pl.DataFrame(rows).with_columns(
+            pl.col("date").cast(pl.Date)
+        ).sort("date")

nseindiapy-0.1.0/src/nseindiapy/holidays.py

@@ -0,0 +1,104 @@
+"""NSE trading holiday calendar.
+
+Note: ``POST /Backpage.aspx/getAllHolidays`` does not exist (HTTP 500,
+"Unknown web method"). Holiday data is scraped from the HTML page at
+``https://www.niftyindices.com/resources/holiday-calendar``.
+"""
+from __future__ import annotations
+
+from datetime import date, timedelta
+
+import polars as pl
+import requests
+from bs4 import BeautifulSoup
+
+from ._http import BASE_URL
+
+_CALENDAR_URL = BASE_URL + "/resources/holiday-calendar"
+
+
+def _scrape_holidays(html: str) -> list[dict]:
+    """Parse holiday rows from the holiday-calendar HTML page.
+
+    Actual page columns (verified June 2026):
+        SR. NO. | Date (DD/MM/YYYY) | Day | Occasion
+    """
+    soup = BeautifulSoup(html, "html.parser")
+    rows = []
+    for tr in soup.find_all("tr"):
+        tds = tr.find_all("td")
+        if len(tds) == 4:
+            sr_no = tds[0].get_text(strip=True)
+            trading_date = tds[1].get_text(strip=True)
+            week_day = tds[2].get_text(strip=True)
+            description = tds[3].get_text(strip=True)
+            # Skip header rows — sr_no must be numeric
+            if sr_no.isdigit() and trading_date:
+                rows.append({
+                    "sr_no": int(sr_no),
+                    "date_str": trading_date,
+                    "week_day": week_day,
+                    "description": description,
+                })
+    return rows
+
+
+class Holidays:
+    def __init__(self, session: requests.Session) -> None:
+        self._s = session
+
+    def get_holidays(self, year: int) -> pl.DataFrame:
+        """Fetch the NSE trading holiday list for *year* by scraping the HTML page.
+
+        Returns a DataFrame with columns:
+            ``sr_no`` (int), ``date`` (Date), ``week_day`` (str), ``description`` (str).
+        """
+        resp = self._s.get(_CALENDAR_URL, params={"year": str(year)}, timeout=20)
+        resp.raise_for_status()
+        raw_rows = _scrape_holidays(resp.text)
+
+        if not raw_rows:
+            return pl.DataFrame(schema={
+                "sr_no": pl.Int64,
+                "date": pl.Date,
+                "week_day": pl.Utf8,
+                "description": pl.Utf8,
+            })
+
+        df = pl.DataFrame(raw_rows)
+        # Date strings on the page are "DD/MM/YYYY" format e.g. "26/01/2026"
+        df = df.with_columns(
+            pl.col("date_str").str.to_date("%d/%m/%Y", strict=False).alias("date")
+        ).drop("date_str")
+
+        return df.drop_nulls(subset=["date"]).sort("date")
+
+    def holiday_dates(self, year: int) -> set[date]:
+        """Return a set of holiday ``date`` objects for *year*."""
+        df = self.get_holidays(year)
+        if df.is_empty() or "date" not in df.columns:
+            return set()
+        return {d for d in df["date"].to_list() if d is not None}
+
+    def trading_days(self, start: date, end: date) -> list[date]:
+        """Return all NSE trading days between *start* and *end* inclusive.
+
+        Fetches the holiday calendar for every calendar year spanned by the range.
+        """
+        holidays: set[date] = set()
+        for y in range(start.year, end.year + 1):
+            holidays |= self.holiday_dates(y)
+
+        days: list[date] = []
+        dt = start
+        while dt <= end:
+            if dt.weekday() < 5 and dt not in holidays:
+                days.append(dt)
+            dt += timedelta(days=1)
+        return days
+
+    def is_trading_day(self, dt: date) -> bool:
+        """Return ``True`` if *dt* is an NSE trading day."""
+        if dt.weekday() >= 5:
+            return False
+        return dt not in self.holiday_dates(dt.year)

nseindiapy-0.1.0/src/nseindiapy/live.py

@@ -0,0 +1,51 @@
+"""Live market data from niftyindices.com CDN.
+
+Note on removed endpoints
+--------------------------
+The following Backpage.aspx methods were found to be non-existent (HTTP 500
+"Unknown web method") during live testing in June 2026 — they are not
+implemented:
+
+* ``getEquityStockWatch`` — page is a redirect button to nseindia.com
+* ``getIndexMovers``       — redirect to nseindia.com
+* ``getETFList``           — redirect to nseindia.com
+* ``getReturnProfileData`` — page is server-rendered; no backing API
+
+Use ``client.historical.price_history()`` or ``client.historical.tri_history()``
+to compute return profiles from raw data.
+"""
+from __future__ import annotations
+
+import requests
+import polars as pl
+
+from ._http import BLOB_URL
+
+
+class LiveMarket:
+    def __init__(self, session: requests.Session) -> None:
+        self._s = session
+
+    def live_indices(self) -> pl.DataFrame:
+        """Snapshot of all live NSE index values from the CDN.
+
+        Endpoint: ``GET https://iislliveblob.niftyindices.com/jsonfiles/LiveIndicesWatch_new.json``
+
+        Refreshed every 15–30 s during market hours (09:15–15:30 IST, Mon–Fri).
+        Outside trading hours the previous session's close data is returned.
+
+        Actual response columns (verified June 2026):
+            ``indexName``, ``last``, ``percChange``, ``icChange``, ``open``,
+            ``high``, ``low``, ``previousClose``, ``timeVal``, ``yearHigh``,
+            ``yearLow``, ``indicativeClose``, ``isConstituents``, ``constituents``
+        """
+        resp = self._s.get(
+            f"{BLOB_URL}/jsonfiles/LiveIndicesWatch_new.json", timeout=10
+        )
+        resp.raise_for_status()
+        payload = resp.json()
+        # CDN returns {"data": [...]} wrapper
+        data: list[dict] = payload.get("data", payload) if isinstance(payload, dict) else payload
+        if not data:
+            return pl.DataFrame()
+        return pl.DataFrame(data)

nseindiapy-0.1.0/src/nseindiapy/reports.py

@@ -0,0 +1,197 @@
+"""Daily and monthly report downloads from niftyindices.com."""
+from __future__ import annotations
+
+import io
+import os
+from datetime import date, timedelta
+
+import polars as pl
+import requests
+
+_BASE = "https://www.niftyindices.com"
+
+_MONTH_UPPER = {
+    1: "JAN", 2: "FEB", 3: "MAR", 4: "APR",
+    5: "MAY", 6: "JUN", 7: "JUL", 8: "AUG",
+    9: "SEP", 10: "OCT", 11: "NOV", 12: "DEC",
+}
+_MONTH_MIXED = {
+    1: "January", 2: "February", 3: "March", 4: "April",
+    5: "May", 6: "June", 7: "July", 8: "August",
+    9: "September", 10: "October", 11: "November", 12: "December",
+}
+
+
+class Reports:
+    def __init__(self, session: requests.Session) -> None:
+        self._s = session
+
+    # ------------------------------------------------------------------
+    # Daily reports
+    # ------------------------------------------------------------------
+
+    def daily_snapshot(self, dt: date) -> pl.DataFrame | None:
+        """Download and parse the daily index snapshot CSV for *dt*.
+
+        Returns a Polars DataFrame or ``None`` if *dt* was a non-trading day
+        (HTTP 404).
+        """
+        url = (
+            f"{_BASE}/Daily_Snapshot/"
+            f"ind_close_all_{dt.strftime('%d%m%Y')}.csv"
+        )
+        resp = self._s.get(url, timeout=30)
+        if resp.status_code == 404:
+            return None
+        resp.raise_for_status()
+        return self._parse_snapshot(resp.content)
+
+    def daily_snapshot_bytes(self, dt: date) -> bytes | None:
+        """Return raw CSV bytes for the daily snapshot, or ``None`` for non-trading days."""
+        url = (
+            f"{_BASE}/Daily_Snapshot/"
+            f"ind_close_all_{dt.strftime('%d%m%Y')}.csv"
+        )
+        resp = self._s.get(url, timeout=30)
+        if resp.status_code == 404:
+            return None
+        resp.raise_for_status()
+        return resp.content
+
+    def daily_snapshot_range(
+        self, start: date, end: date
+    ) -> pl.DataFrame:
+        """Download and combine daily snapshots for all trading days in [start, end]."""
+        frames: list[pl.DataFrame] = []
+        dt = start
+        while dt <= end:
+            df = self.daily_snapshot(dt)
+            if df is not None:
+                frames.append(df)
+            dt += timedelta(days=1)
+        return pl.concat(frames) if frames else pl.DataFrame()
+
+    @staticmethod
+    def _parse_snapshot(content: bytes) -> pl.DataFrame:
+        df = pl.read_csv(
+            io.BytesIO(content),
+            encoding="utf8-lossy",
+            infer_schema_length=0,
+        )
+        df = df.rename({c: c.strip() for c in df.columns})
+        numeric_cols = [
+            "Open Index Value", "High Index Value", "Low Index Value",
+            "Closing Index Value", "Points Change", "Change(%)",
+            "Volume", "Turnover (Rs. Cr.)", "P/E", "P/B", "Div Yield",
+        ]
+        casts = []
+        for col in numeric_cols:
+            if col in df.columns:
+                casts.append(
+                    pl.col(col)
+                    .str.replace_all(",", "")
+                    .str.strip_chars()
+                    .cast(pl.Float64, strict=False)
+                    .alias(col)
+                )
+        if "Index Date" in df.columns:
+            casts.append(
+                pl.col("Index Date")
+                .str.to_date("%d-%b-%Y", strict=False)
+                .alias("Index Date")
+            )
+        return df.with_columns(casts) if casts else df
+
+    # ------------------------------------------------------------------
+    # Monthly report URLs
+    # ------------------------------------------------------------------
+
+    def monthly_urls(self, year: int, month: int) -> dict[str, str]:
+        """Return all known monthly report URLs for *year/month*."""
+        mmm = _MONTH_UPPER[month]
+        mon = _MONTH_MIXED[month]
+        y = str(year)
+        return {
+            "index_dashboard_equity": (
+                f"{_BASE}/Index_Dashboard/Index_Dashboard_{mmm}{y}.pdf"
+            ),
+            "index_dashboard_fixed_income": (
+                f"{_BASE}/Index_Dashboard_Fixed_Income/"
+                f"Index_Dashboard_FixedIncome_{mmm}{y}.pdf"
+            ),
+            "market_cap_weightage": (
+                f"{_BASE}/Market_Cap_Weightage/"
+                f"Market_Cap_Weightage_{mon}{y}.zip"
+            ),
+            "impact_cost": (
+                f"{_BASE}/Impact_Cost/Impact_Cost_{mmm}{y}.pdf"
+            ),
+            "passive_insights": (
+                f"{_BASE}/Nifty_Passive_Insights/"
+                f"NiftyPassiveFundReport-{mon}{y}.pdf"
+            ),
+        }
+
+    def download_monthly(
+        self,
+        year: int,
+        month: int,
+        dest_dir: str = ".",
+    ) -> dict[str, str]:
+        """Download all monthly reports into *dest_dir*.
+
+        Returns a mapping of report name → saved file path (or an error
+        message if the file was not found).
+        """
+        os.makedirs(dest_dir, exist_ok=True)
+        urls = self.monthly_urls(year, month)
+        results: dict[str, str] = {}
+        for name, url in urls.items():
+            resp = self._s.get(url, timeout=60)
+            if resp.status_code == 404:
+                results[name] = f"NOT FOUND: {url}"
+                continue
+            resp.raise_for_status()
+            ext = url.rsplit(".", 1)[-1]
+            path = os.path.join(dest_dir, f"{name}_{year}_{month:02d}.{ext}")
+            with open(path, "wb") as f:
+                f.write(resp.content)
+            results[name] = path
+        return results
+
+    # ------------------------------------------------------------------
+    # Static resource downloads
+    # ------------------------------------------------------------------
+
+    _RESOURCES: dict[str, str] = {
+        "methodology_equity": (
+            f"{_BASE}/Methodology/Method_NIFTY_Equity_Indices.pdf"
+        ),
+        "methodology_fixed_income": (
+            f"{_BASE}/Methodology/Method_NIFTY_Fixed_Income_Indices.pdf"
+        ),
+        "tracking_error": (
+            f"{_BASE}/docs/default-source/tracking-error/trackingerror.pdf"
+        ),
+        "benchmark_codes": (
+            f"{_BASE}/BenchmarkCodes/Nifty_Indices_Benchmark_Codes.pdf"
+        ),
+    }
+
+    def resource_urls(self) -> dict[str, str]:
+        """Return URLs for static methodology and reference documents."""
+        return dict(self._RESOURCES)
+
+    def download_resource(self, name: str, dest_path: str) -> str:
+        """Download a named static resource PDF to *dest_path*."""
+        if name not in self._RESOURCES:
+            raise ValueError(
+                f"Unknown resource '{name}'. "
+                f"Available: {list(self._RESOURCES)}"
+            )
+        url = self._RESOURCES[name]
+        resp = self._s.get(url, timeout=60)
+        resp.raise_for_status()
+        with open(dest_path, "wb") as f:
+            f.write(resp.content)
+        return dest_path