oq-core 0.1.0__tar.gz

oq_core-0.1.0/.gitignore

@@ -0,0 +1,82 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+*.egg
+*.egg-info/
+dist/
+build/
+wheels/
+develop-eggs/
+eggs/
+parts/
+sdist/
+var/
+*.manifest
+*.spec
+pip-log.txt
+pip-delete-this-directory.txt
+
+# uv
+.venv/
+venv/
+env/
+ENV/
+.python-version
+
+# Testing / coverage
+.pytest_cache/
+.coverage
+.coverage.*
+htmlcov/
+.tox/
+.nox/
+coverage.xml
+*.cover
+.cache
+
+# mypy / ruff
+.mypy_cache/
+.ruff_cache/
+.dmypy.json
+dmypy.json
+
+# Jupyter
+.ipynb_checkpoints/
+*.ipynb_checkpoints
+
+# Data / artifacts
+data/
+*.parquet
+*.duckdb
+*.duckdb.wal
+*.csv.gz
+*.zip
+.openquant/
+
+!packages/*/tests/fixtures/**
+
+# IDE / OS
+.idea/
+.vscode/
+*.swp
+*.swo
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+logs/
+
+# Secrets
+.env
+.env.*
+!.env.example
+*.pem
+*.key
+
+# build artifacts
+dist/
+*.egg-info/

oq_core-0.1.0/PKG-INFO

@@ -0,0 +1,36 @@
+Metadata-Version: 2.4
+Name: oq-core
+Version: 0.1.0
+Summary: Shared primitives for the OpenQuant India ecosystem: Instrument, TradingCalendar, config.
+Project-URL: Homepage, https://github.com/revorhq/openquant
+Project-URL: Repository, https://github.com/revorhq/openquant
+Project-URL: Issues, https://github.com/revorhq/openquant/issues
+Author: OpenQuant India Contributors
+License: Apache-2.0
+Keywords: backtesting,finance,india,nse,quant,trading
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# oq-core
+
+Shared primitives for the OpenQuant India ecosystem.
+
+- `Instrument` — typed model for an exchange-listed instrument (symbol, ISIN, exchange, segment, lot size).
+- `TradingCalendar` — NSE trading calendar with holidays, weekends, and muhurat sessions.
+
+Install:
+
+```bash
+pip install oq-core
+```
+
+See the [main repository](https://github.com/openquant-india/openquant) for the full project, license, and disclaimers.

oq_core-0.1.0/README.md

@@ -0,0 +1,14 @@
+# oq-core
+
+Shared primitives for the OpenQuant India ecosystem.
+
+- `Instrument` — typed model for an exchange-listed instrument (symbol, ISIN, exchange, segment, lot size).
+- `TradingCalendar` — NSE trading calendar with holidays, weekends, and muhurat sessions.
+
+Install:
+
+```bash
+pip install oq-core
+```
+
+See the [main repository](https://github.com/openquant-india/openquant) for the full project, license, and disclaimers.

oq_core-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[project]
+name = "oq-core"
+version = "0.1.0"
+description = "Shared primitives for the OpenQuant India ecosystem: Instrument, TradingCalendar, config."
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "Apache-2.0" }
+authors = [{ name = "OpenQuant India Contributors" }]
+keywords = ["quant", "trading", "india", "nse", "backtesting", "finance"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Financial and Insurance Industry",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Office/Business :: Financial :: Investment",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/revorhq/openquant"
+Repository = "https://github.com/revorhq/openquant"
+Issues = "https://github.com/revorhq/openquant/issues"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/oq_core"]

oq_core-0.1.0/src/oq_core/__init__.py

@@ -0,0 +1,14 @@
+"""oq-core: shared primitives for the OpenQuant India ecosystem."""
+
+from oq_core.calendar import TradingCalendar
+from oq_core.instrument import Exchange, Instrument, Segment
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "Exchange",
+    "Instrument",
+    "Segment",
+    "TradingCalendar",
+    "__version__",
+]

oq_core-0.1.0/src/oq_core/calendar.py

@@ -0,0 +1,192 @@
+"""NSE trading calendar.
+
+This module implements a minimal-but-correct NSE equity trading calendar:
+
+* Mon-Fri are trading days.
+* Saturday and Sunday are non-trading days.
+* A curated set of NSE trading holidays is loaded from
+  :data:`HOLIDAYS_BY_YEAR`.
+* Muhurat (Diwali) sessions are special trading days where the date would
+  otherwise be a holiday or where only an evening session is open.
+
+The calendar API is intentionally small and deterministic so that ``oq-data``
+and ``oq-backtest`` can rely on it without pulling pandas at import time.
+
+Holiday lists are maintained by year. They are best-effort and should be
+verified against the NSE annual circular for any production usage.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from dataclasses import dataclass
+from datetime import date, datetime, time, timedelta
+
+NSE_OPEN = time(9, 15)
+NSE_CLOSE = time(15, 30)
+
+
+@dataclass(frozen=True, slots=True)
+class MuhuratSession:
+    """A Diwali muhurat trading session (evening, typically ~1 hour)."""
+
+    session_date: date
+    open_time: time
+    close_time: time
+
+
+# NSE trading holidays. Source: NSE annual holiday circulars.
+# Only includes fully-closed equity trading days (not settlement holidays).
+# This list is best-effort; consumers should verify against the NSE circular.
+HOLIDAYS_BY_YEAR: dict[int, frozenset[date]] = {
+    2023: frozenset(
+        {
+            date(2023, 1, 26),  # Republic Day
+            date(2023, 3, 7),  # Holi
+            date(2023, 3, 30),  # Ram Navami
+            date(2023, 4, 4),  # Mahavir Jayanti
+            date(2023, 4, 7),  # Good Friday
+            date(2023, 4, 14),  # Dr. Ambedkar Jayanti
+            date(2023, 5, 1),  # Maharashtra Day
+            date(2023, 6, 28),  # Bakri Id
+            date(2023, 8, 15),  # Independence Day
+            date(2023, 9, 19),  # Ganesh Chaturthi
+            date(2023, 10, 2),  # Gandhi Jayanti
+            date(2023, 10, 24),  # Dussehra
+            date(2023, 11, 14),  # Diwali Balipratipada
+            date(2023, 11, 27),  # Guru Nanak Jayanti
+            date(2023, 12, 25),  # Christmas
+        }
+    ),
+    2024: frozenset(
+        {
+            date(2024, 1, 26),  # Republic Day
+            date(2024, 3, 8),  # Mahashivratri
+            date(2024, 3, 25),  # Holi
+            date(2024, 3, 29),  # Good Friday
+            date(2024, 4, 11),  # Id-Ul-Fitr
+            date(2024, 4, 17),  # Ram Navami
+            date(2024, 5, 1),  # Maharashtra Day
+            date(2024, 5, 20),  # General Elections (Mumbai)
+            date(2024, 6, 17),  # Bakri Id
+            date(2024, 7, 17),  # Muharram
+            date(2024, 8, 15),  # Independence Day
+            date(2024, 10, 2),  # Gandhi Jayanti
+            date(2024, 11, 1),  # Diwali Laxmi Pujan (full holiday; muhurat session in evening)
+            date(2024, 11, 15),  # Guru Nanak Jayanti
+            date(2024, 12, 25),  # Christmas
+        }
+    ),
+    2025: frozenset(
+        {
+            date(2025, 2, 26),  # Mahashivratri
+            date(2025, 3, 14),  # Holi
+            date(2025, 3, 31),  # Id-Ul-Fitr
+            date(2025, 4, 10),  # Mahavir Jayanti
+            date(2025, 4, 14),  # Dr. Ambedkar Jayanti
+            date(2025, 4, 18),  # Good Friday
+            date(2025, 5, 1),  # Maharashtra Day
+            date(2025, 8, 15),  # Independence Day
+            date(2025, 8, 27),  # Ganesh Chaturthi
+            date(2025, 10, 2),  # Gandhi Jayanti / Dussehra
+            date(2025, 10, 21),  # Diwali Laxmi Pujan (muhurat session in evening)
+            date(2025, 10, 22),  # Diwali Balipratipada
+            date(2025, 11, 5),  # Guru Nanak Jayanti
+            date(2025, 12, 25),  # Christmas
+        }
+    ),
+}
+
+
+# Muhurat (Diwali) trading sessions. These are evening sessions on what would
+# otherwise be a non-trading day.
+MUHURAT_SESSIONS: tuple[MuhuratSession, ...] = (
+    MuhuratSession(date(2023, 11, 12), time(18, 15), time(19, 15)),
+    MuhuratSession(date(2024, 11, 1), time(18, 0), time(19, 0)),
+    MuhuratSession(date(2025, 10, 21), time(13, 45), time(14, 45)),
+)
+
+
+class TradingCalendar:
+    """NSE equity trading calendar.
+
+    Parameters
+    ----------
+    holidays:
+        Optional override mapping of year to holiday set. Defaults to the
+        bundled :data:`HOLIDAYS_BY_YEAR`.
+    muhurat:
+        Optional override of muhurat sessions. Defaults to
+        :data:`MUHURAT_SESSIONS`.
+    """
+
+    def __init__(
+        self,
+        holidays: dict[int, frozenset[date]] | None = None,
+        muhurat: tuple[MuhuratSession, ...] | None = None,
+    ) -> None:
+        self._holidays: dict[int, frozenset[date]] = (
+            dict(holidays) if holidays is not None else dict(HOLIDAYS_BY_YEAR)
+        )
+        self._muhurat: dict[date, MuhuratSession] = {
+            session.session_date: session
+            for session in (muhurat if muhurat is not None else MUHURAT_SESSIONS)
+        }
+
+    def is_weekend(self, day: date) -> bool:
+        return day.weekday() >= 5
+
+    def is_holiday(self, day: date) -> bool:
+        """True if ``day`` is on the published NSE holiday list."""
+        return day in self._holidays.get(day.year, frozenset())
+
+    def muhurat_session(self, day: date) -> MuhuratSession | None:
+        """Return the muhurat session for ``day``, if any."""
+        return self._muhurat.get(day)
+
+    def is_session(self, day: date) -> bool:
+        """True if regular trading happens on ``day`` (excludes muhurat-only days)."""
+        if self.is_weekend(day):
+            return False
+        return not self.is_holiday(day)
+
+    def is_trading_day(self, day: date) -> bool:
+        """True if any trading occurs on ``day`` (regular session OR muhurat)."""
+        if self.is_session(day):
+            return True
+        return day in self._muhurat
+
+    def next_session(self, day: date) -> date:
+        """Smallest ``d > day`` that is a regular session."""
+        candidate = day + timedelta(days=1)
+        while not self.is_session(candidate):
+            candidate += timedelta(days=1)
+        return candidate
+
+    def previous_session(self, day: date) -> date:
+        """Largest ``d < day`` that is a regular session."""
+        candidate = day - timedelta(days=1)
+        while not self.is_session(candidate):
+            candidate -= timedelta(days=1)
+        return candidate
+
+    def sessions(self, start: date, end: date) -> Iterator[date]:
+        """Yield regular trading sessions in ``[start, end]`` inclusive."""
+        if end < start:
+            return
+        current = start
+        while current <= end:
+            if self.is_session(current):
+                yield current
+            current += timedelta(days=1)
+
+    def session_count(self, start: date, end: date) -> int:
+        """Number of regular trading sessions in ``[start, end]`` inclusive."""
+        return sum(1 for _ in self.sessions(start, end))
+
+    def is_market_open(self, when: datetime) -> bool:
+        """True if the regular cash market is open at ``when`` (naive local IST)."""
+        day = when.date()
+        if not self.is_session(day):
+            return False
+        return NSE_OPEN <= when.time() <= NSE_CLOSE

oq_core-0.1.0/src/oq_core/instrument.py

@@ -0,0 +1,92 @@
+"""Instrument model: a typed representation of an exchange-listed instrument."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from enum import StrEnum
+
+_ISIN_PATTERN = re.compile(r"^[A-Z]{2}[A-Z0-9]{9}\d$")
+_SYMBOL_PATTERN = re.compile(r"^[A-Z0-9][A-Z0-9&\-\.]{0,49}$")
+
+
+class Exchange(StrEnum):
+    """Indian exchanges supported by OpenQuant."""
+
+    NSE = "NSE"
+    BSE = "BSE"
+
+
+class Segment(StrEnum):
+    """Market segments within an exchange."""
+
+    EQ = "EQ"
+    FUT = "FUT"
+    OPT = "OPT"
+    CDS = "CDS"
+    COM = "COM"
+
+
+@dataclass(frozen=True, slots=True)
+class Instrument:
+    """A single exchange-listed instrument.
+
+    Identity is ``(exchange, segment, symbol)``. ``isin`` is the canonical
+    cross-exchange identifier used to follow corporate actions and renames
+    (e.g. the HDFC/HDFC Bank merger).
+
+    Parameters
+    ----------
+    symbol:
+        Trading symbol as listed on the exchange (uppercase). For NSE EQ this
+        is the tradingsymbol (e.g. ``"RELIANCE"``).
+    isin:
+        12-character ISIN (e.g. ``"INE002A01018"``). Required for equities;
+        optional for derivatives.
+    exchange:
+        Listing exchange.
+    segment:
+        Market segment (EQ, FUT, OPT, CDS, COM).
+    lot_size:
+        Minimum tradable quantity. ``1`` for cash equities, varies for F&O.
+    tick_size:
+        Minimum price increment in INR. Defaults to ``0.05``.
+    name:
+        Human-readable company / contract name.
+    """
+
+    symbol: str
+    exchange: Exchange = Exchange.NSE
+    segment: Segment = Segment.EQ
+    isin: str | None = None
+    lot_size: int = 1
+    tick_size: float = 0.05
+    name: str | None = None
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.symbol, str) or not self.symbol:
+            raise ValueError("symbol must be a non-empty string")
+        if not _SYMBOL_PATTERN.match(self.symbol):
+            raise ValueError(
+                f"invalid symbol {self.symbol!r}: must be uppercase alphanumeric "
+                "(plus & - .), up to 50 chars"
+            )
+        if self.isin is not None and not _ISIN_PATTERN.match(self.isin):
+            raise ValueError(
+                f"invalid ISIN {self.isin!r}: expected 12 chars matching "
+                "country(2) + alphanumeric(9) + checksum(1)"
+            )
+        if self.segment is Segment.EQ and self.isin is None:
+            raise ValueError("equity instruments require an ISIN")
+        if self.lot_size < 1:
+            raise ValueError(f"lot_size must be >= 1, got {self.lot_size}")
+        if self.tick_size <= 0:
+            raise ValueError(f"tick_size must be > 0, got {self.tick_size}")
+
+    @property
+    def key(self) -> tuple[str, str, str]:
+        """Stable identity tuple suitable for dict keys."""
+        return (self.exchange.value, self.segment.value, self.symbol)
+
+    def __str__(self) -> str:
+        return f"{self.exchange.value}:{self.segment.value}:{self.symbol}"

oq_core-0.1.0/tests/test_calendar.py

@@ -0,0 +1,126 @@
+"""Tests for oq_core.calendar."""
+
+from __future__ import annotations
+
+from datetime import date, datetime, time
+
+import pytest
+from oq_core import TradingCalendar
+from oq_core.calendar import MUHURAT_SESSIONS, MuhuratSession
+
+
+@pytest.fixture
+def cal() -> TradingCalendar:
+    return TradingCalendar()
+
+
+class TestWeekends:
+    def test_saturday_is_weekend(self, cal: TradingCalendar) -> None:
+        assert cal.is_weekend(date(2024, 6, 8))  # Saturday
+        assert not cal.is_session(date(2024, 6, 8))
+
+    def test_sunday_is_weekend(self, cal: TradingCalendar) -> None:
+        assert cal.is_weekend(date(2024, 6, 9))  # Sunday
+        assert not cal.is_session(date(2024, 6, 9))
+
+    def test_weekday_not_weekend(self, cal: TradingCalendar) -> None:
+        assert not cal.is_weekend(date(2024, 6, 10))  # Monday
+
+
+class TestHolidays:
+    def test_republic_day_2024(self, cal: TradingCalendar) -> None:
+        assert cal.is_holiday(date(2024, 1, 26))
+        assert not cal.is_session(date(2024, 1, 26))
+
+    def test_christmas_2025(self, cal: TradingCalendar) -> None:
+        assert cal.is_holiday(date(2025, 12, 25))
+
+    def test_regular_weekday_not_holiday(self, cal: TradingCalendar) -> None:
+        assert not cal.is_holiday(date(2024, 6, 10))
+        assert cal.is_session(date(2024, 6, 10))
+
+    def test_unknown_year_no_holidays(self, cal: TradingCalendar) -> None:
+        assert not cal.is_holiday(date(2099, 1, 26))
+
+
+class TestMuhurat:
+    def test_known_muhurat_dates_present(self) -> None:
+        dates = {s.session_date for s in MUHURAT_SESSIONS}
+        assert date(2024, 11, 1) in dates
+        assert date(2025, 10, 21) in dates
+
+    def test_muhurat_lookup(self, cal: TradingCalendar) -> None:
+        s = cal.muhurat_session(date(2024, 11, 1))
+        assert s is not None
+        assert s.open_time < s.close_time
+
+    def test_muhurat_only_day_is_trading_not_session(self) -> None:
+        # 2024-11-01 is a Diwali holiday but has a muhurat session
+        cal = TradingCalendar()
+        d = date(2024, 11, 1)
+        assert cal.is_holiday(d)
+        assert not cal.is_session(d)
+        assert cal.is_trading_day(d)
+
+
+class TestNavigation:
+    def test_next_session_skips_weekend(self, cal: TradingCalendar) -> None:
+        # Friday 2024-06-07 -> next session Monday 2024-06-10
+        assert cal.next_session(date(2024, 6, 7)) == date(2024, 6, 10)
+
+    def test_previous_session_skips_weekend(self, cal: TradingCalendar) -> None:
+        # Monday 2024-06-10 -> previous session Friday 2024-06-07
+        assert cal.previous_session(date(2024, 6, 10)) == date(2024, 6, 7)
+
+    def test_next_session_skips_holiday(self, cal: TradingCalendar) -> None:
+        # 2024-08-15 (Thu) is Independence Day -> next session 2024-08-16 (Fri)
+        assert cal.next_session(date(2024, 8, 14)) == date(2024, 8, 16)
+
+
+class TestSessionRange:
+    def test_sessions_in_week(self, cal: TradingCalendar) -> None:
+        # Mon 2024-06-10 to Sun 2024-06-16: 5 sessions
+        days = list(cal.sessions(date(2024, 6, 10), date(2024, 6, 16)))
+        assert len(days) == 5
+        assert days[0] == date(2024, 6, 10)
+        assert days[-1] == date(2024, 6, 14)
+
+    def test_sessions_empty_when_end_before_start(self, cal: TradingCalendar) -> None:
+        assert list(cal.sessions(date(2024, 6, 10), date(2024, 6, 5))) == []
+
+    def test_session_count_around_holiday(self, cal: TradingCalendar) -> None:
+        # Week of Independence Day 2024 (Thu Aug 15): Mon-Fri minus Thu = 4
+        assert cal.session_count(date(2024, 8, 12), date(2024, 8, 16)) == 4
+
+
+class TestMarketHours:
+    def test_open_at_open_time(self, cal: TradingCalendar) -> None:
+        assert cal.is_market_open(datetime(2024, 6, 10, 9, 15))
+
+    def test_open_mid_session(self, cal: TradingCalendar) -> None:
+        assert cal.is_market_open(datetime(2024, 6, 10, 12, 0))
+
+    def test_closed_before_open(self, cal: TradingCalendar) -> None:
+        assert not cal.is_market_open(datetime(2024, 6, 10, 9, 0))
+
+    def test_closed_after_close(self, cal: TradingCalendar) -> None:
+        assert not cal.is_market_open(datetime(2024, 6, 10, 15, 31))
+
+    def test_closed_on_weekend(self, cal: TradingCalendar) -> None:
+        assert not cal.is_market_open(datetime(2024, 6, 8, 12, 0))
+
+    def test_closed_on_holiday(self, cal: TradingCalendar) -> None:
+        assert not cal.is_market_open(datetime(2024, 1, 26, 12, 0))
+
+
+class TestOverrides:
+    def test_custom_holidays(self) -> None:
+        custom = {2030: frozenset({date(2030, 1, 1)})}
+        cal = TradingCalendar(holidays=custom)
+        assert cal.is_holiday(date(2030, 1, 1))
+        assert not cal.is_holiday(date(2024, 1, 26))
+
+    def test_custom_muhurat(self) -> None:
+        s = MuhuratSession(date(2030, 11, 5), time(18, 0), time(19, 0))
+        cal = TradingCalendar(muhurat=(s,))
+        assert cal.muhurat_session(date(2030, 11, 5)) == s

oq_core-0.1.0/tests/test_instrument.py

@@ -0,0 +1,84 @@
+"""Tests for oq_core.instrument."""
+
+from __future__ import annotations
+
+import pytest
+from oq_core import Exchange, Instrument, Segment
+
+
+class TestInstrumentValid:
+    def test_minimal_equity(self) -> None:
+        ins = Instrument(symbol="RELIANCE", isin="INE002A01018")
+        assert ins.symbol == "RELIANCE"
+        assert ins.isin == "INE002A01018"
+        assert ins.exchange is Exchange.NSE
+        assert ins.segment is Segment.EQ
+        assert ins.lot_size == 1
+        assert ins.tick_size == 0.05
+
+    def test_symbol_with_special_chars(self) -> None:
+        ins = Instrument(symbol="M&M", isin="INE101A01026")
+        assert ins.symbol == "M&M"
+
+    def test_hyphen_and_dot_allowed(self) -> None:
+        Instrument(symbol="L&T-FH", isin="INE498L01015")
+        Instrument(symbol="NIFTY-25JUN", segment=Segment.FUT, lot_size=75)
+
+    def test_derivative_no_isin_ok(self) -> None:
+        ins = Instrument(
+            symbol="NIFTY25JUNFUT",
+            segment=Segment.FUT,
+            lot_size=75,
+            tick_size=0.05,
+        )
+        assert ins.isin is None
+        assert ins.lot_size == 75
+
+    def test_frozen(self) -> None:
+        ins = Instrument(symbol="RELIANCE", isin="INE002A01018")
+        with pytest.raises(AttributeError):
+            ins.symbol = "INFY"  # type: ignore[misc]
+
+    def test_key_tuple(self) -> None:
+        ins = Instrument(symbol="RELIANCE", isin="INE002A01018")
+        assert ins.key == ("NSE", "EQ", "RELIANCE")
+
+    def test_str(self) -> None:
+        ins = Instrument(symbol="RELIANCE", isin="INE002A01018")
+        assert str(ins) == "NSE:EQ:RELIANCE"
+
+    def test_hashable(self) -> None:
+        a = Instrument(symbol="RELIANCE", isin="INE002A01018")
+        b = Instrument(symbol="RELIANCE", isin="INE002A01018")
+        assert hash(a) == hash(b)
+        assert {a, b} == {a}
+
+
+class TestInstrumentInvalid:
+    def test_empty_symbol(self) -> None:
+        with pytest.raises(ValueError, match="symbol"):
+            Instrument(symbol="", isin="INE002A01018")
+
+    def test_lowercase_symbol(self) -> None:
+        with pytest.raises(ValueError, match="symbol"):
+            Instrument(symbol="reliance", isin="INE002A01018")
+
+    def test_bad_isin_length(self) -> None:
+        with pytest.raises(ValueError, match="ISIN"):
+            Instrument(symbol="RELIANCE", isin="INE002A0101")
+
+    def test_bad_isin_country(self) -> None:
+        with pytest.raises(ValueError, match="ISIN"):
+            Instrument(symbol="RELIANCE", isin="1NE002A01018")
+
+    def test_equity_requires_isin(self) -> None:
+        with pytest.raises(ValueError, match="equity"):
+            Instrument(symbol="RELIANCE")
+
+    def test_zero_lot_size(self) -> None:
+        with pytest.raises(ValueError, match="lot_size"):
+            Instrument(symbol="RELIANCE", isin="INE002A01018", lot_size=0)
+
+    def test_negative_tick(self) -> None:
+        with pytest.raises(ValueError, match="tick_size"):
+            Instrument(symbol="RELIANCE", isin="INE002A01018", tick_size=-0.01)