nubra-ref-data 0.1.0__tar.gz

nubra_ref_data-0.1.0/LICENSE

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

nubra_ref_data-0.1.0/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: nubra_ref_data
+Version: 0.1.0
+Summary: Reference-data helpers for Nubra InstrumentData option, future, and underlying DataFrames
+Author: Akshay N
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/akshayn-spec/nubra_ref_data
+Project-URL: Repository, https://github.com/akshayn-spec/nubra_ref_data
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=2.0
+Dynamic: license-file
+
+# nubra_ref_data
+
+`nubra_ref_data` is a small helper package for Nubra `InstrumentData` users who want filtered pandas DataFrames for:
+
+- the underlying row
+- futures rows
+- option rows by expiry bucket and strike levels
+- one combined DataFrame containing all of the above
+
+It is designed to work with:
+
+```python
+from nubra_python_sdk.refdata.instruments import InstrumentData
+
+instruments = InstrumentData(nubra)
+```
+
+## Install
+
+```bash
+pip install nubra_ref_data
+```
+
+## Functions
+
+- `underlying_data(instruments, underlying, exchange="NSE")`
+- `futures_data(instruments, underlying, exchange="NSE")`
+- `options_data(instruments, underlying, exchange="NSE", expiry_bucket="week0", levels=10, option_side="BOTH")`
+- `all_data(instruments, underlying, exchange="NSE", expiry_bucket="week0", levels=10, option_side="BOTH")`
+
+## Example
+
+```python
+from nubra_python_sdk.start_sdk import InitNubraSdk, NubraEnv
+from nubra_python_sdk.refdata.instruments import InstrumentData
+
+from nubra_ref_data import all_data, options_data
+
+
+nubra = InitNubraSdk(NubraEnv.UAT, env_creds=True)
+instruments = InstrumentData(nubra)
+
+df_all = all_data(
+    instruments=instruments,
+    underlying="NIFTY",
+    exchange="NSE",
+    expiry_bucket="week0",
+    levels=8,
+    option_side="BOTH",
+)
+
+df_ce = options_data(
+    instruments=instruments,
+    underlying="NIFTY",
+    exchange="NSE",
+    expiry_bucket="month",
+    levels=5,
+    option_side="CE",
+)
+
+df_sensex = all_data(
+    instruments=instruments,
+    underlying="SENSEX",
+    exchange="BSE",
+    expiry_bucket="week0",
+    levels=6,
+    option_side="BOTH",
+)
+```
+
+## Behavior
+
+- `week0`, `week1`, `week2`, `week3`, and `week4` resolve against the sorted available option expiries for that underlying.
+- `month` resolves to the first month-end expiry available in the option data.
+- `levels` picks the nearest strikes using `underlying_prev_close`.
+- `option_side="BOTH"` only selects strikes where both `CE` and `PE` exist.
+- `all_data()` returns rows in this order: underlying, futures, then options.
+- If the underlying cash/index row is missing from the instruments master, a placeholder `UNDERLYING` row is added.
+- The returned DataFrames preserve the original instrument columns only. No helper columns are added.

nubra_ref_data-0.1.0/README.md

@@ -0,0 +1,79 @@
+# nubra_ref_data
+
+`nubra_ref_data` is a small helper package for Nubra `InstrumentData` users who want filtered pandas DataFrames for:
+
+- the underlying row
+- futures rows
+- option rows by expiry bucket and strike levels
+- one combined DataFrame containing all of the above
+
+It is designed to work with:
+
+```python
+from nubra_python_sdk.refdata.instruments import InstrumentData
+
+instruments = InstrumentData(nubra)
+```
+
+## Install
+
+```bash
+pip install nubra_ref_data
+```
+
+## Functions
+
+- `underlying_data(instruments, underlying, exchange="NSE")`
+- `futures_data(instruments, underlying, exchange="NSE")`
+- `options_data(instruments, underlying, exchange="NSE", expiry_bucket="week0", levels=10, option_side="BOTH")`
+- `all_data(instruments, underlying, exchange="NSE", expiry_bucket="week0", levels=10, option_side="BOTH")`
+
+## Example
+
+```python
+from nubra_python_sdk.start_sdk import InitNubraSdk, NubraEnv
+from nubra_python_sdk.refdata.instruments import InstrumentData
+
+from nubra_ref_data import all_data, options_data
+
+
+nubra = InitNubraSdk(NubraEnv.UAT, env_creds=True)
+instruments = InstrumentData(nubra)
+
+df_all = all_data(
+    instruments=instruments,
+    underlying="NIFTY",
+    exchange="NSE",
+    expiry_bucket="week0",
+    levels=8,
+    option_side="BOTH",
+)
+
+df_ce = options_data(
+    instruments=instruments,
+    underlying="NIFTY",
+    exchange="NSE",
+    expiry_bucket="month",
+    levels=5,
+    option_side="CE",
+)
+
+df_sensex = all_data(
+    instruments=instruments,
+    underlying="SENSEX",
+    exchange="BSE",
+    expiry_bucket="week0",
+    levels=6,
+    option_side="BOTH",
+)
+```
+
+## Behavior
+
+- `week0`, `week1`, `week2`, `week3`, and `week4` resolve against the sorted available option expiries for that underlying.
+- `month` resolves to the first month-end expiry available in the option data.
+- `levels` picks the nearest strikes using `underlying_prev_close`.
+- `option_side="BOTH"` only selects strikes where both `CE` and `PE` exist.
+- `all_data()` returns rows in this order: underlying, futures, then options.
+- If the underlying cash/index row is missing from the instruments master, a placeholder `UNDERLYING` row is added.
+- The returned DataFrames preserve the original instrument columns only. No helper columns are added.

nubra_ref_data-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "nubra_ref_data"
+version = "0.1.0"
+description = "Reference-data helpers for Nubra InstrumentData option, future, and underlying DataFrames"
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+authors = [{ name = "Akshay N" }]
+dependencies = [
+  "pandas>=2.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/akshayn-spec/nubra_ref_data"
+Repository = "https://github.com/akshayn-spec/nubra_ref_data"
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+
+[tool.setuptools.packages.find]
+where = ["src"]

nubra_ref_data-0.1.0/setup.cfg

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

nubra_ref_data-0.1.0/src/nubra_ref_data/__init__.py

@@ -0,0 +1,3 @@
+from .refdata import all_data, futures_data, options_data, underlying_data
+
+__all__ = ["underlying_data", "futures_data", "options_data", "all_data"]

nubra_ref_data-0.1.0/src/nubra_ref_data/refdata.py

@@ -0,0 +1,253 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import re
+from typing import Any
+
+import pandas as pd
+
+
+WEEK_PATTERN = re.compile(r"^week(?P<index>\d+)$")
+OPTION_TYPES = {"CE", "PE"}
+BASE_COLUMNS = [
+    "stock_name",
+    "ref_id",
+    "exchange",
+    "asset",
+    "asset_type",
+    "derivative_type",
+    "expiry",
+    "strike_price",
+    "option_type",
+    "lot_size",
+    "tick_size",
+    "token",
+    "nubra_name",
+    "isin",
+    "underlying_prev_close",
+]
+@dataclass(frozen=True)
+class ResolvedExpiry:
+    bucket: str
+    expiry: int
+
+
+def _normalize_text(value: Any) -> str:
+    if value is None:
+        return ""
+    return str(value).strip().upper()
+
+
+def _to_numeric(series: pd.Series) -> pd.Series:
+    return pd.to_numeric(series, errors="coerce")
+
+
+def _normalize_option_side(option_side: str | None) -> str:
+    side = _normalize_text(option_side or "BOTH")
+    aliases = {
+        "BOTH": "BOTH",
+        "ALL": "BOTH",
+        "CE": "CE",
+        "CALL": "CE",
+        "CALLS": "CE",
+        "PE": "PE",
+        "PUT": "PE",
+        "PUTS": "PE",
+    }
+    normalized = aliases.get(side)
+    if normalized is None:
+        raise ValueError("option_side must be one of BOTH, CE, PE, CALL, or PUT.")
+    return normalized
+
+
+def _ensure_dataframe(instruments: Any, exchange: str) -> pd.DataFrame:
+    if not hasattr(instruments, "get_instruments_dataframe"):
+        raise TypeError("instruments must expose get_instruments_dataframe(exchange=...).")
+
+    df = instruments.get_instruments_dataframe(exchange=exchange)
+    if not isinstance(df, pd.DataFrame):
+        raise TypeError("get_instruments_dataframe(exchange=...) must return a pandas DataFrame.")
+
+    missing = [column for column in BASE_COLUMNS if column not in df.columns]
+    if missing:
+        raise ValueError(f"Instrument DataFrame is missing required columns: {missing}")
+
+    df = df.copy()
+    df["exchange"] = df["exchange"].astype(str).str.upper()
+    df["asset"] = df["asset"].astype(str).str.upper()
+    df["derivative_type"] = df["derivative_type"].astype(str).str.upper()
+    df["option_type"] = df["option_type"].astype(str).str.upper()
+    df["stock_name"] = df["stock_name"].astype(str)
+    df["expiry"] = _to_numeric(df["expiry"]).astype("Int64")
+    df["strike_price"] = _to_numeric(df["strike_price"])
+    df["underlying_prev_close"] = _to_numeric(df["underlying_prev_close"])
+    return df
+
+
+def _asset_dataframe(instruments: Any, underlying: str, exchange: str) -> pd.DataFrame:
+    exchange_code = _normalize_text(exchange)
+    underlying_name = _normalize_text(underlying)
+    df = _ensure_dataframe(instruments, exchange=exchange_code)
+    asset_df = df[(df["exchange"] == exchange_code) & (df["asset"] == underlying_name)].copy()
+    if asset_df.empty:
+        raise ValueError(f"No instruments found for underlying={underlying_name!r} on exchange={exchange_code!r}.")
+    return asset_df
+
+
+def _resolve_expiry_bucket(option_expiries: list[int], expiry_bucket: str) -> ResolvedExpiry:
+    if not option_expiries:
+        raise ValueError("No option expiries are available for the selected underlying and exchange.")
+
+    bucket = _normalize_text(expiry_bucket)
+    if bucket == "MONTH":
+        by_month: dict[tuple[int, int], list[int]] = {}
+        for expiry in option_expiries:
+            expiry_str = str(expiry)
+            month_key = (int(expiry_str[:4]), int(expiry_str[4:6]))
+            by_month.setdefault(month_key, []).append(expiry)
+        first_month_key = sorted(by_month)[0]
+        return ResolvedExpiry(bucket="MONTH", expiry=max(by_month[first_month_key]))
+
+    match = WEEK_PATTERN.match(bucket.lower())
+    if match is None:
+        raise ValueError("expiry_bucket must look like week0, week1, week2, week3, week4, or month.")
+
+    index = int(match.group("index"))
+    if index >= len(option_expiries):
+        raise ValueError(
+            f"expiry_bucket={expiry_bucket!r} is out of range for the available expiries: {option_expiries}"
+        )
+    return ResolvedExpiry(bucket=f"WEEK{index}", expiry=option_expiries[index])
+
+
+def underlying_data(instruments: Any, underlying: str, exchange: str = "NSE") -> pd.DataFrame:
+    asset_df = _asset_dataframe(instruments=instruments, underlying=underlying, exchange=exchange)
+    stock_name = asset_df["stock_name"].astype(str).str.upper()
+    derivative_type = asset_df["derivative_type"].astype(str).str.upper()
+    underlying_name = _normalize_text(underlying)
+    rows = asset_df[(stock_name == underlying_name) & (~derivative_type.isin(["OPT", "FUT"]))].copy()
+
+    if rows.empty:
+        underlying_prev_close = asset_df["underlying_prev_close"].dropna()
+        placeholder = {
+            "stock_name": underlying_name,
+            "ref_id": pd.NA,
+            "exchange": _normalize_text(exchange),
+            "asset": underlying_name,
+            "asset_type": pd.NA,
+            "derivative_type": "SPOT",
+            "expiry": pd.NA,
+            "strike_price": pd.NA,
+            "option_type": pd.NA,
+            "lot_size": pd.NA,
+            "tick_size": pd.NA,
+            "token": pd.NA,
+            "nubra_name": pd.NA,
+            "isin": pd.NA,
+            "underlying_prev_close": underlying_prev_close.iloc[0] if not underlying_prev_close.empty else pd.NA,
+        }
+        rows = pd.DataFrame([placeholder], columns=BASE_COLUMNS)
+
+    return rows[BASE_COLUMNS].reset_index(drop=True)
+
+
+def futures_data(instruments: Any, underlying: str, exchange: str = "NSE") -> pd.DataFrame:
+    asset_df = _asset_dataframe(instruments=instruments, underlying=underlying, exchange=exchange)
+    rows = asset_df[asset_df["derivative_type"] == "FUT"].copy()
+    rows = rows.sort_values(by=["expiry", "stock_name"], kind="stable")
+    return rows[BASE_COLUMNS].reset_index(drop=True)
+
+
+def options_data(
+    instruments: Any,
+    underlying: str,
+    exchange: str = "NSE",
+    expiry_bucket: str = "week0",
+    levels: int = 10,
+    option_side: str = "BOTH",
+) -> pd.DataFrame:
+    if levels <= 0:
+        raise ValueError("levels must be greater than 0.")
+
+    asset_df = _asset_dataframe(instruments=instruments, underlying=underlying, exchange=exchange)
+    option_rows = asset_df[asset_df["derivative_type"] == "OPT"].copy()
+    if option_rows.empty:
+        raise ValueError(f"No option instruments found for underlying={_normalize_text(underlying)!r}.")
+
+    side = _normalize_option_side(option_side)
+    option_expiries = sorted(int(value) for value in option_rows["expiry"].dropna().unique().tolist())
+    resolved = _resolve_expiry_bucket(option_expiries, expiry_bucket)
+
+    rows = option_rows[option_rows["expiry"] == resolved.expiry].copy()
+    if rows.empty:
+        raise ValueError(f"No option instruments found for expiry={resolved.expiry}.")
+
+    ce_rows = rows[rows["option_type"] == "CE"].copy()
+    pe_rows = rows[rows["option_type"] == "PE"].copy()
+    ce_strikes = set(ce_rows["strike_price"].dropna().tolist())
+    pe_strikes = set(pe_rows["strike_price"].dropna().tolist())
+
+    if side == "BOTH":
+        valid_strikes = sorted(ce_strikes & pe_strikes)
+    elif side == "CE":
+        valid_strikes = sorted(ce_strikes)
+    else:
+        valid_strikes = sorted(pe_strikes)
+
+    if not valid_strikes:
+        raise ValueError("No matching option rows were found for the selected filters.")
+
+    underlying_prev_close_series = rows["underlying_prev_close"].dropna()
+    underlying_prev_close = (
+        float(underlying_prev_close_series.iloc[0])
+        if not underlying_prev_close_series.empty
+        else float(valid_strikes[len(valid_strikes) // 2])
+    )
+
+    ranked_strikes = sorted(valid_strikes, key=lambda strike: (abs(strike - underlying_prev_close), strike))
+    selected_strikes = ranked_strikes[: min(levels, len(ranked_strikes))]
+    rank_map = {strike: index + 1 for index, strike in enumerate(selected_strikes)}
+
+    rows = rows[rows["strike_price"].isin(selected_strikes)].copy()
+    if side in OPTION_TYPES:
+        rows = rows[rows["option_type"] == side].copy()
+    else:
+        rows = rows[rows["option_type"].isin(["CE", "PE"])].copy()
+
+    if side == "CE":
+        rows = rows.sort_values(by=["strike_price"], ascending=[True], kind="stable")
+        return rows[BASE_COLUMNS].reset_index(drop=True)
+
+    if side == "PE":
+        rows = rows.sort_values(by=["strike_price"], ascending=[False], kind="stable")
+        return rows[BASE_COLUMNS].reset_index(drop=True)
+
+    ce_output = rows[rows["option_type"] == "CE"].sort_values(by=["strike_price"], ascending=[True], kind="stable")
+    pe_output = rows[rows["option_type"] == "PE"].sort_values(by=["strike_price"], ascending=[False], kind="stable")
+    final_rows = pd.concat([ce_output, pe_output], ignore_index=True, sort=False)
+    return final_rows[BASE_COLUMNS].reset_index(drop=True)
+
+
+def all_data(
+    instruments: Any,
+    underlying: str,
+    exchange: str = "NSE",
+    expiry_bucket: str = "week0",
+    levels: int = 10,
+    option_side: str = "BOTH",
+) -> pd.DataFrame:
+    frames = [
+        underlying_data(instruments=instruments, underlying=underlying, exchange=exchange),
+        futures_data(instruments=instruments, underlying=underlying, exchange=exchange),
+        options_data(
+            instruments=instruments,
+            underlying=underlying,
+            exchange=exchange,
+            expiry_bucket=expiry_bucket,
+            levels=levels,
+            option_side=option_side,
+        ),
+    ]
+    concat_frames = [frame.dropna(axis=1, how="all") for frame in frames if not frame.empty]
+    final_df = pd.concat(concat_frames, ignore_index=True, sort=False)
+    return final_df[BASE_COLUMNS].reset_index(drop=True)

nubra_ref_data-0.1.0/src/nubra_ref_data.egg-info/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: nubra_ref_data
+Version: 0.1.0
+Summary: Reference-data helpers for Nubra InstrumentData option, future, and underlying DataFrames
+Author: Akshay N
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/akshayn-spec/nubra_ref_data
+Project-URL: Repository, https://github.com/akshayn-spec/nubra_ref_data
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=2.0
+Dynamic: license-file
+
+# nubra_ref_data
+
+`nubra_ref_data` is a small helper package for Nubra `InstrumentData` users who want filtered pandas DataFrames for:
+
+- the underlying row
+- futures rows
+- option rows by expiry bucket and strike levels
+- one combined DataFrame containing all of the above
+
+It is designed to work with:
+
+```python
+from nubra_python_sdk.refdata.instruments import InstrumentData
+
+instruments = InstrumentData(nubra)
+```
+
+## Install
+
+```bash
+pip install nubra_ref_data
+```
+
+## Functions
+
+- `underlying_data(instruments, underlying, exchange="NSE")`
+- `futures_data(instruments, underlying, exchange="NSE")`
+- `options_data(instruments, underlying, exchange="NSE", expiry_bucket="week0", levels=10, option_side="BOTH")`
+- `all_data(instruments, underlying, exchange="NSE", expiry_bucket="week0", levels=10, option_side="BOTH")`
+
+## Example
+
+```python
+from nubra_python_sdk.start_sdk import InitNubraSdk, NubraEnv
+from nubra_python_sdk.refdata.instruments import InstrumentData
+
+from nubra_ref_data import all_data, options_data
+
+
+nubra = InitNubraSdk(NubraEnv.UAT, env_creds=True)
+instruments = InstrumentData(nubra)
+
+df_all = all_data(
+    instruments=instruments,
+    underlying="NIFTY",
+    exchange="NSE",
+    expiry_bucket="week0",
+    levels=8,
+    option_side="BOTH",
+)
+
+df_ce = options_data(
+    instruments=instruments,
+    underlying="NIFTY",
+    exchange="NSE",
+    expiry_bucket="month",
+    levels=5,
+    option_side="CE",
+)
+
+df_sensex = all_data(
+    instruments=instruments,
+    underlying="SENSEX",
+    exchange="BSE",
+    expiry_bucket="week0",
+    levels=6,
+    option_side="BOTH",
+)
+```
+
+## Behavior
+
+- `week0`, `week1`, `week2`, `week3`, and `week4` resolve against the sorted available option expiries for that underlying.
+- `month` resolves to the first month-end expiry available in the option data.
+- `levels` picks the nearest strikes using `underlying_prev_close`.
+- `option_side="BOTH"` only selects strikes where both `CE` and `PE` exist.
+- `all_data()` returns rows in this order: underlying, futures, then options.
+- If the underlying cash/index row is missing from the instruments master, a placeholder `UNDERLYING` row is added.
+- The returned DataFrames preserve the original instrument columns only. No helper columns are added.

nubra_ref_data-0.1.0/src/nubra_ref_data.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+src/nubra_ref_data/__init__.py
+src/nubra_ref_data/refdata.py
+src/nubra_ref_data.egg-info/PKG-INFO
+src/nubra_ref_data.egg-info/SOURCES.txt
+src/nubra_ref_data.egg-info/dependency_links.txt
+src/nubra_ref_data.egg-info/requires.txt
+src/nubra_ref_data.egg-info/top_level.txt
+tests/test_refdata.py

nubra_ref_data-0.1.0/src/nubra_ref_data.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

nubra_ref_data-0.1.0/src/nubra_ref_data.egg-info/requires.txt

@@ -0,0 +1 @@
+pandas>=2.0

nubra_ref_data-0.1.0/src/nubra_ref_data.egg-info/top_level.txt

@@ -0,0 +1 @@
+nubra_ref_data

nubra_ref_data-0.1.0/tests/test_refdata.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+import unittest
+
+import pandas as pd
+
+from nubra_ref_data import all_data, futures_data, options_data, underlying_data
+
+
+class FakeInstruments:
+    def __init__(self, dataframe: pd.DataFrame) -> None:
+        self._dataframe = dataframe
+
+    def get_instruments_dataframe(self, exchange: str | None = None) -> pd.DataFrame:
+        df = self._dataframe.copy()
+        if exchange is None:
+            return df
+        return df[df["exchange"].astype(str).str.upper() == str(exchange).upper()].reset_index(drop=True)
+
+
+def _sample_df() -> pd.DataFrame:
+    rows = [
+        {
+            "stock_name": "RELIANCE",
+            "ref_id": 1,
+            "exchange": "NSE",
+            "asset": "RELIANCE",
+            "asset_type": "STOCKS",
+            "derivative_type": "",
+            "expiry": pd.NA,
+            "strike_price": pd.NA,
+            "option_type": pd.NA,
+            "lot_size": 1,
+            "tick_size": 5,
+            "token": 101,
+            "nubra_name": "STOCK_RELIANCE.NSECM",
+            "isin": "INE002A01018",
+            "underlying_prev_close": 201000.0,
+        },
+        {
+            "stock_name": "RELIANCE26MARFUT",
+            "ref_id": 2,
+            "exchange": "NSE",
+            "asset": "RELIANCE",
+            "asset_type": "STOCK_FO",
+            "derivative_type": "FUT",
+            "expiry": 20260326,
+            "strike_price": -1,
+            "option_type": pd.NA,
+            "lot_size": 250,
+            "tick_size": 5,
+            "token": 102,
+            "nubra_name": "FUT_RELIANCE_20260326",
+            "isin": pd.NA,
+            "underlying_prev_close": 201000.0,
+        },
+        {
+            "stock_name": "RELIANCE26APRFUT",
+            "ref_id": 3,
+            "exchange": "NSE",
+            "asset": "RELIANCE",
+            "asset_type": "STOCK_FO",
+            "derivative_type": "FUT",
+            "expiry": 20260430,
+            "strike_price": -1,
+            "option_type": pd.NA,
+            "lot_size": 250,
+            "tick_size": 5,
+            "token": 103,
+            "nubra_name": "FUT_RELIANCE_20260430",
+            "isin": pd.NA,
+            "underlying_prev_close": 201000.0,
+        },
+    ]
+    expiries = [20260319, 20260326, 20260430]
+    strikes = [199000, 200000, 201000, 202000]
+    ref_id = 100
+    for expiry in expiries:
+        for strike in strikes:
+            for option_type in ["CE", "PE"]:
+                rows.append(
+                    {
+                        "stock_name": f"RELIANCE{expiry}{strike}{option_type}",
+                        "ref_id": ref_id,
+                        "exchange": "NSE",
+                        "asset": "RELIANCE",
+                        "asset_type": "STOCK_FO",
+                        "derivative_type": "OPT",
+                        "expiry": expiry,
+                        "strike_price": strike,
+                        "option_type": option_type,
+                        "lot_size": 250,
+                        "tick_size": 5,
+                        "token": 1000 + ref_id,
+                        "nubra_name": f"OPT_RELIANCE_{expiry}_{option_type}_{strike}",
+                        "isin": pd.NA,
+                        "underlying_prev_close": 201000.0,
+                    }
+                )
+                ref_id += 1
+    return pd.DataFrame(rows)
+
+
+class NubraRefDataTests(unittest.TestCase):
+    def setUp(self) -> None:
+        self.instruments = FakeInstruments(_sample_df())
+
+    def test_underlying_data_returns_stock_row(self) -> None:
+        result = underlying_data(self.instruments, underlying="RELIANCE", exchange="NSE")
+        self.assertEqual(len(result), 1)
+        self.assertEqual(result.iloc[0]["stock_name"], "RELIANCE")
+        self.assertEqual(list(result.columns), [
+            "stock_name", "ref_id", "exchange", "asset", "asset_type", "derivative_type",
+            "expiry", "strike_price", "option_type", "lot_size", "tick_size", "token",
+            "nubra_name", "isin", "underlying_prev_close",
+        ])
+
+    def test_futures_data_returns_all_futures(self) -> None:
+        result = futures_data(self.instruments, underlying="RELIANCE", exchange="NSE")
+        self.assertEqual(len(result), 2)
+        self.assertEqual(set(result["derivative_type"].tolist()), {"FUT"})
+
+    def test_options_data_resolves_week_bucket_and_levels(self) -> None:
+        result = options_data(
+            self.instruments,
+            underlying="RELIANCE",
+            exchange="NSE",
+            expiry_bucket="week0",
+            levels=2,
+            option_side="BOTH",
+        )
+        self.assertEqual(len(result), 4)
+        self.assertEqual(set(result["option_type"].tolist()), {"CE", "PE"})
+        self.assertEqual(result["expiry"].dropna().astype(int).unique().tolist(), [20260319])
+        self.assertEqual(result["option_type"].tolist(), ["CE", "CE", "PE", "PE"])
+        self.assertEqual(result["strike_price"].tolist(), [200000, 201000, 201000, 200000])
+
+    def test_ce_and_pe_are_separated_with_requested_ordering(self) -> None:
+        result = options_data(
+            self.instruments,
+            underlying="RELIANCE",
+            exchange="NSE",
+            expiry_bucket="week0",
+            levels=3,
+            option_side="BOTH",
+        )
+        ce_rows = result[result["option_type"] == "CE"]
+        pe_rows = result[result["option_type"] == "PE"]
+        self.assertEqual(ce_rows["strike_price"].tolist(), [200000, 201000, 202000])
+        self.assertEqual(pe_rows["strike_price"].tolist(), [202000, 201000, 200000])
+
+    def test_all_data_combines_underlying_futures_and_options(self) -> None:
+        result = all_data(
+            self.instruments,
+            underlying="RELIANCE",
+            exchange="NSE",
+            expiry_bucket="month",
+            levels=1,
+            option_side="PE",
+        )
+        self.assertEqual(result.iloc[0]["stock_name"], "RELIANCE")
+        option_rows = result[result["derivative_type"] == "OPT"]
+        self.assertEqual(len(option_rows), 1)
+        self.assertEqual(option_rows["expiry"].dropna().astype(int).unique().tolist(), [20260326])
+
+
+if __name__ == "__main__":
+    unittest.main()