tejhq 0.2.0__py3-none-any.whl

tej/__init__.py

@@ -0,0 +1,73 @@
+"""Python SDK for `tej-api <https://api.tejhq.dev>`_.
+
+Zero runtime dependencies. Sync + async clients with identical surface.
+
+Quick start::
+
+    from tej import Client
+
+    c = Client()
+    rows = c.ohlcv("RELIANCE", "nse", "2025-01-01", "2025-01-31")
+    print(len(rows))
+
+Async::
+
+    import asyncio
+    from tej import AsyncClient
+
+    async def main():
+        async with AsyncClient() as c:
+            return await c.ohlcv("RELIANCE", "nse", "2025-01-01", "2025-01-31")
+
+    asyncio.run(main())
+"""
+
+from ._version import __version__
+from .async_client import AsyncClient
+from .client import Client
+from .exceptions import (
+    AuthError,
+    BadRequestError,
+    NetworkError,
+    NotFoundError,
+    ProRequiredError,
+    RateLimitError,
+    ServerError,
+    TejError,
+)
+from .models import (
+    OHLCV,
+    Action,
+    AdjustedRow,
+    Envelope,
+    Exchange,
+    MetricsRow,
+    ResolveHit,
+    SnapshotRow,
+    SymbolInterval,
+    UniverseMember,
+)
+
+__all__ = [
+    "__version__",
+    "Action",
+    "AdjustedRow",
+    "AsyncClient",
+    "AuthError",
+    "BadRequestError",
+    "Client",
+    "Envelope",
+    "Exchange",
+    "MetricsRow",
+    "NetworkError",
+    "NotFoundError",
+    "OHLCV",
+    "ProRequiredError",
+    "RateLimitError",
+    "ResolveHit",
+    "ServerError",
+    "SnapshotRow",
+    "SymbolInterval",
+    "TejError",
+    "UniverseMember",
+]

tej/_http.py

@@ -0,0 +1,183 @@
+"""Stdlib HTTP transport shared by the sync and async clients.
+
+Zero runtime deps. Sync uses ``urllib.request``. Async wraps sync calls in
+``asyncio.to_thread`` so concurrent fetches via ``asyncio.gather`` still get
+real parallelism without dragging in ``httpx``/``aiohttp``.
+"""
+
+from __future__ import annotations
+
+import json
+import random
+import re
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from collections.abc import Mapping
+from typing import Any, Callable
+
+from ._version import __version__
+from .exceptions import NetworkError, ServerError, TejError, from_status
+
+DEFAULT_BASE_URL = "https://api.tejhq.dev"
+DEFAULT_TIMEOUT = 30.0
+DEFAULT_MAX_RETRIES = 3
+DEFAULT_BACKOFF_BASE = 0.4
+DEFAULT_BACKOFF_CAP = 4.0
+USER_AGENT = f"tej-sdk-py/{__version__}"
+
+RETRYABLE_STATUSES = frozenset({429, 500, 502, 503, 504})
+
+_SYMBOL_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9\-&]{0,29}$")
+_EXCHANGE_VALUES = frozenset({"nse", "bse"})
+_DATE_RE = re.compile(r"^\d{4}-\d{2}-\d{2}$")
+
+
+def normalize_exchange(value: str) -> str:
+    """Lowercase + validate against `nse` | `bse`."""
+    if not isinstance(value, str):
+        raise ValueError(f"exchange must be str, got {type(value).__name__}")
+    v = value.strip().lower()
+    if v not in _EXCHANGE_VALUES:
+        raise ValueError(f"exchange must be 'nse' or 'bse', got {value!r}")
+    return v
+
+
+def normalize_symbol(value: str) -> str:
+    if not isinstance(value, str):
+        raise ValueError(f"symbol must be str, got {type(value).__name__}")
+    v = value.strip().upper()
+    if not _SYMBOL_RE.match(v):
+        raise ValueError(
+            f"symbol must match [A-Z0-9][A-Z0-9-&]{{0,29}}, got {value!r}"
+        )
+    return v
+
+
+def validate_date(value: str, field: str) -> str:
+    if not isinstance(value, str):
+        raise ValueError(f"{field} must be str (YYYY-MM-DD), got {type(value).__name__}")
+    if not _DATE_RE.match(value):
+        raise ValueError(f"{field} must be YYYY-MM-DD, got {value!r}")
+    return value
+
+
+def build_url(base_url: str, path: str, query: Mapping[str, Any] | None = None) -> str:
+    url = base_url.rstrip("/") + "/" + path.lstrip("/")
+    if query:
+        items = [(k, str(v)) for k, v in query.items() if v is not None]
+        if items:
+            url = url + "?" + urllib.parse.urlencode(items)
+    return url
+
+
+def _backoff_sleep(attempt: int, base: float, cap: float) -> float:
+    expo = min(cap, base * (2 ** attempt))
+    jitter = random.uniform(0, expo / 2)
+    return float(expo / 2 + jitter)
+
+
+def _parse_body(raw: bytes, status: int, request_id: str | None) -> Any:
+    if not raw:
+        return None
+    try:
+        return json.loads(raw.decode("utf-8"))
+    except (UnicodeDecodeError, json.JSONDecodeError) as exc:
+        if 200 <= status < 300:
+            raise TejError(
+                f"failed to decode JSON response: {exc}",
+                status_code=status,
+                request_id=request_id,
+            ) from exc
+        return None
+
+
+def _raise_for_status(status: int, body: Any, request_id: str | None) -> None:
+    if 200 <= status < 300:
+        return
+    error_code: str | None = None
+    message = f"HTTP {status}"
+    if isinstance(body, dict):
+        error_code = body.get("error") if isinstance(body.get("error"), str) else None
+        msg = body.get("message")
+        if isinstance(msg, str) and msg:
+            message = msg
+        elif error_code:
+            message = error_code
+    raise from_status(status, message, error_code=error_code, request_id=request_id)
+
+
+def request_json(
+    method: str,
+    url: str,
+    *,
+    headers: Mapping[str, str] | None = None,
+    timeout: float = DEFAULT_TIMEOUT,
+    max_retries: int = DEFAULT_MAX_RETRIES,
+    backoff_base: float = DEFAULT_BACKOFF_BASE,
+    backoff_cap: float = DEFAULT_BACKOFF_CAP,
+    sleep: Callable[[float], None] = time.sleep,
+) -> tuple[int, Any, Mapping[str, str]]:
+    """One HTTP round-trip with retry/backoff.
+
+    Returns ``(status, parsed_json_or_none, response_headers)``. Raises
+    :class:`TejError` on 4xx/5xx after exhausting retries, or
+    :class:`NetworkError` on transport failure.
+    """
+    merged_headers = {"User-Agent": USER_AGENT, "Accept": "application/json"}
+    if headers:
+        merged_headers.update(headers)
+
+    last_exc: BaseException | None = None
+    for attempt in range(max_retries + 1):
+        req = urllib.request.Request(url, method=method, headers=dict(merged_headers))
+        try:
+            with urllib.request.urlopen(req, timeout=timeout) as resp:
+                status = resp.status
+                resp_headers = {k.lower(): v for k, v in resp.headers.items()}
+                raw = resp.read()
+                request_id = resp_headers.get("x-request-id")
+                body = _parse_body(raw, status, request_id)
+                if status in RETRYABLE_STATUSES and attempt < max_retries:
+                    sleep(_backoff_sleep(attempt, backoff_base, backoff_cap))
+                    continue
+                _raise_for_status(status, body, request_id)
+                return status, body, resp_headers
+        except urllib.error.HTTPError as exc:
+            status = exc.code
+            resp_headers = {k.lower(): v for k, v in exc.headers.items()} if exc.headers else {}
+            raw = exc.read() if hasattr(exc, "read") else b""
+            request_id = resp_headers.get("x-request-id")
+            body = _parse_body(raw, status, request_id)
+            if status in RETRYABLE_STATUSES and attempt < max_retries:
+                sleep(_backoff_sleep(attempt, backoff_base, backoff_cap))
+                continue
+            _raise_for_status(status, body, request_id)
+            return status, body, resp_headers  # unreachable; keeps type checker happy
+        except urllib.error.URLError as exc:
+            last_exc = exc
+            if attempt < max_retries:
+                sleep(_backoff_sleep(attempt, backoff_base, backoff_cap))
+                continue
+            raise NetworkError(f"request to {url} failed: {exc.reason}") from exc
+        except TimeoutError as exc:
+            last_exc = exc
+            if attempt < max_retries:
+                sleep(_backoff_sleep(attempt, backoff_base, backoff_cap))
+                continue
+            raise NetworkError(f"request to {url} timed out after {timeout}s") from exc
+
+    raise NetworkError(f"request to {url} failed after {max_retries} retries: {last_exc}")
+
+
+def envelope_data(body: Any) -> list[dict[str, Any]]:
+    """Extract the ``data`` array from a standard envelope response."""
+    if not isinstance(body, dict):
+        raise ServerError(f"unexpected response shape: {type(body).__name__}")
+    data = body.get("data")
+    if data is None:
+        return []
+    if not isinstance(data, list):
+        raise ServerError(f"response 'data' must be a list, got {type(data).__name__}")
+    return data

tej/_version.py

@@ -0,0 +1 @@
+__version__ = "0.2.0"

tej/async_client.py

@@ -0,0 +1,293 @@
+"""Asynchronous client for tej-api.
+
+>>> import asyncio
+>>> from tej import AsyncClient
+>>>
+>>> async def main():
+...     async with AsyncClient() as c:
+...         rows = await c.ohlcv("RELIANCE", "nse", "2025-01-01", "2025-01-31")
+...         return len(rows)
+>>> asyncio.run(main())
+21
+
+The zero-runtime-dependency rule means we cannot pull in ``httpx`` or
+``aiohttp``. ``asyncio.to_thread`` runs the blocking stdlib ``urllib`` call in
+the default executor, which still gives real parallelism for ``gather``-style
+concurrent fan-out (each in-flight request occupies one worker thread). For
+ten or so concurrent EOD requests this is indistinguishable from native async
+I/O. If you need to fan out hundreds of requests, raise the loop's executor
+size with ``loop.set_default_executor(ThreadPoolExecutor(max_workers=N))``.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Iterable, Mapping
+from types import TracebackType
+from typing import Any, cast
+
+from . import _http
+from .models import (
+    OHLCV,
+    Action,
+    AdjustedRow,
+    Envelope,
+    MetricsRow,
+    ResolveHit,
+    SnapshotRow,
+    SymbolInterval,
+    UniverseMember,
+)
+
+
+class AsyncClient:
+    """Asynchronous client. Same surface as :class:`Client` with `await`."""
+
+    def __init__(
+        self,
+        *,
+        base_url: str = _http.DEFAULT_BASE_URL,
+        api_key: str | None = None,
+        timeout: float = _http.DEFAULT_TIMEOUT,
+        max_retries: int = _http.DEFAULT_MAX_RETRIES,
+        user_agent_suffix: str | None = None,
+        default_headers: Mapping[str, str] | None = None,
+    ) -> None:
+        self.base_url = base_url
+        self.api_key = api_key
+        self.timeout = timeout
+        self.max_retries = max_retries
+
+        headers: dict[str, str] = {}
+        if default_headers:
+            headers.update(default_headers)
+        if api_key:
+            headers["Authorization"] = f"Bearer {api_key}"
+        if user_agent_suffix:
+            headers["User-Agent"] = f"{_http.USER_AGENT} {user_agent_suffix}"
+        self._headers = headers
+
+    async def __aenter__(self) -> AsyncClient:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        await self.aclose()
+
+    async def aclose(self) -> None:
+        return None
+
+    async def _get(self, path: str, query: Mapping[str, Any] | None = None) -> Any:
+        url = _http.build_url(self.base_url, path, query)
+        result = await asyncio.to_thread(
+            _http.request_json,
+            "GET",
+            url,
+            headers=self._headers,
+            timeout=self.timeout,
+            max_retries=self.max_retries,
+        )
+        _, body, _ = result
+        return body
+
+    # ---- system probes -------------------------------------------------
+
+    async def health(self) -> dict[str, Any]:
+        body = await self._get("/health")
+        return body if isinstance(body, dict) else {}
+
+    async def ready(self) -> dict[str, Any]:
+        body = await self._get("/ready")
+        return body if isinstance(body, dict) else {}
+
+    # ---- market data ---------------------------------------------------
+
+    async def ohlcv(
+        self,
+        symbol: str,
+        exchange: str,
+        from_: str | None = None,
+        to: str | None = None,
+    ) -> list[OHLCV]:
+        ex = _http.normalize_exchange(exchange)
+        sym = _http.normalize_symbol(symbol)
+        query: dict[str, str] = {}
+        if from_ is not None:
+            query["from"] = _http.validate_date(from_, "from_")
+        if to is not None:
+            query["to"] = _http.validate_date(to, "to")
+        body = await self._get(f"/v1/ohlcv/{ex}/{sym}", query or None)
+        return _http.envelope_data(body)  # type: ignore[return-value]
+
+    async def snapshot(self, exchange: str, date: str) -> list[SnapshotRow]:
+        ex = _http.normalize_exchange(exchange)
+        d = _http.validate_date(date, "date")
+        body = await self._get(f"/v1/snapshot/{ex}", {"date": d})
+        return _http.envelope_data(body)  # type: ignore[return-value]
+
+    async def actions(self, symbol: str) -> list[Action]:
+        sym = _http.normalize_symbol(symbol)
+        body = await self._get(f"/v1/actions/{sym}")
+        return _http.envelope_data(body)  # type: ignore[return-value]
+
+    # ---- free key tier -------------------------------------------------
+
+    async def adjusted(
+        self,
+        symbol: str,
+        exchange: str,
+        from_: str | None = None,
+        to: str | None = None,
+    ) -> list[AdjustedRow]:
+        """Back-adjusted prices for one symbol. Needs a free API key.
+
+        Same range semantics as :meth:`ohlcv`. Adds ``adj_factor_cumulative``
+        and ``adj_close``, continuous through splits, bonuses and dividends.
+        """
+        ex = _http.normalize_exchange(exchange)
+        sym = _http.normalize_symbol(symbol)
+        body = await self._get(f"/v1/adjusted/{ex}/{sym}", _range_query(from_, to))
+        return _http.envelope_data(body)  # type: ignore[return-value]
+
+    async def symbols(
+        self,
+        exchange: str,
+        *,
+        symbol: str | None = None,
+        isin: str | None = None,
+    ) -> list[SymbolInterval]:
+        """Symbol history by ``symbol`` or ``isin``. Needs a free API key.
+
+        One row per contiguous run of an ISIN under a symbol.
+        """
+        if symbol is None and isin is None:
+            raise ValueError("pass symbol= or isin=")
+        ex = _http.normalize_exchange(exchange)
+        query: dict[str, str] = {}
+        if symbol is not None:
+            query["symbol"] = _http.normalize_symbol(symbol)
+        if isin is not None:
+            query["isin"] = isin.strip().upper()
+        body = await self._get(f"/v1/symbols/{ex}", query)
+        return _http.envelope_data(body)  # type: ignore[return-value]
+
+    async def me(self) -> dict[str, Any]:
+        """Account, keys and today's usage for the calling key."""
+        body = await self._get("/v1/me")
+        return body if isinstance(body, dict) else {}
+
+    # ---- pro tier ------------------------------------------------------
+
+    async def metrics(
+        self,
+        symbol: str,
+        exchange: str,
+        from_: str | None = None,
+        to: str | None = None,
+    ) -> list[MetricsRow]:
+        """Per-day derived metrics on adjusted close. Needs a Pro key.
+
+        Returns at 1/5/21/63/126/252 days and YTD, 52-week high and low with
+        distance, average volume and turnover. Rolling fields are ``None``
+        until a full window of history exists.
+        """
+        ex = _http.normalize_exchange(exchange)
+        sym = _http.normalize_symbol(symbol)
+        body = await self._get(f"/v1/metrics/{ex}/{sym}", _range_query(from_, to))
+        return _http.envelope_data(body)  # type: ignore[return-value]
+
+    async def universe(
+        self,
+        name: str = "liquid500",
+        exchange: str = "nse",
+        as_of: str | None = None,
+    ) -> list[UniverseMember]:
+        """Point-in-time liquidity universe. Needs a Pro key.
+
+        ``name`` is ``liquid100``, ``liquid250`` or ``liquid500``: the top N
+        by trailing 63-day turnover at the latest monthly rebalance on or
+        before ``as_of`` (default today). Delisted names stay in the months
+        they qualified for, so there is no survivorship bias.
+        """
+        n = name.strip().lower()
+        if n not in ("liquid100", "liquid250", "liquid500"):
+            raise ValueError("name must be liquid100, liquid250 or liquid500")
+        query: dict[str, str] = {"exchange": _http.normalize_exchange(exchange)}
+        if as_of is not None:
+            query["as_of"] = _http.validate_date(as_of, "as_of")
+        body = await self._get(f"/v1/universe/{n}", query)
+        return _http.envelope_data(body)  # type: ignore[return-value]
+
+    async def batch(
+        self,
+        symbols: Iterable[str],
+        exchange: str = "nse",
+        from_: str | None = None,
+        to: str | None = None,
+    ) -> dict[str, list[OHLCV]]:
+        """OHLCV for up to 50 symbols in one request. Needs a Pro key.
+
+        Returns a dict keyed by symbol; unknown symbols map to ``[]``.
+        """
+        syms = [_http.normalize_symbol(s) for s in symbols]
+        if not syms:
+            raise ValueError("symbols must not be empty")
+        if len(syms) > 50:
+            raise ValueError("at most 50 symbols per batch")
+        query = _range_query(from_, to) or {}
+        query["symbols"] = ",".join(syms)
+        query["exchange"] = _http.normalize_exchange(exchange)
+        body = await self._get("/v1/batch", query)
+        data = body.get("data") if isinstance(body, dict) else None
+        return data if isinstance(data, dict) else {}
+
+    async def resolve(
+        self,
+        q: str,
+        exchange: str = "both",
+        limit: int = 5,
+    ) -> list[ResolveHit]:
+        """Resolve free text to symbols. Needs a Pro key.
+
+        ``"Reliance Industries"``, ``"tata mot"``, ``"infosis"`` or a former
+        ticker like ``"ZOMATO"`` all resolve. Best match first, with
+        ``score`` and ``matched_on``.
+        """
+        q = q.strip()
+        if not 2 <= len(q) <= 80:
+            raise ValueError("q must be 2 to 80 characters")
+        if not 1 <= limit <= 25:
+            raise ValueError("limit must be 1 to 25")
+        ex = "both" if exchange.lower() == "both" else _http.normalize_exchange(exchange)
+        body = await self._get("/v1/resolve", {"q": q, "exchange": ex, "limit": str(limit)})
+        return _http.envelope_data(body)  # type: ignore[return-value]
+
+    async def ohlcv_envelope(
+        self,
+        symbol: str,
+        exchange: str,
+        from_: str | None = None,
+        to: str | None = None,
+    ) -> Envelope:
+        ex = _http.normalize_exchange(exchange)
+        sym = _http.normalize_symbol(symbol)
+        query: dict[str, str] = {}
+        if from_ is not None:
+            query["from"] = _http.validate_date(from_, "from_")
+        if to is not None:
+            query["to"] = _http.validate_date(to, "to")
+        body = await self._get(f"/v1/ohlcv/{ex}/{sym}", query or None)
+        return cast(Envelope, body) if isinstance(body, dict) else Envelope(data=[])
+
+
+def _range_query(from_: str | None, to: str | None) -> dict[str, str] | None:
+    query: dict[str, str] = {}
+    if from_ is not None:
+        query["from"] = _http.validate_date(from_, "from_")
+    if to is not None:
+        query["to"] = _http.validate_date(to, "to")
+    return query or None

tej/client.py

@@ -0,0 +1,308 @@
+"""Synchronous client for tej-api.
+
+>>> from tej import Client
+>>> c = Client()
+>>> rows = c.ohlcv("RELIANCE", "nse", "2025-01-01", "2025-01-31")
+>>> len(rows)
+21
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping
+from types import TracebackType
+from typing import Any, cast
+
+from . import _http
+from .models import (
+    OHLCV,
+    Action,
+    AdjustedRow,
+    Envelope,
+    MetricsRow,
+    ResolveHit,
+    SnapshotRow,
+    SymbolInterval,
+    UniverseMember,
+)
+
+
+class Client:
+    """Synchronous client.
+
+    Args:
+        base_url: API base URL. Defaults to https://api.tejhq.dev.
+        api_key: Optional API key, sent as ``Authorization: Bearer <key>``.
+            Not required for any free-tier endpoint.
+        timeout: Per-request timeout in seconds.
+        max_retries: How many times to retry on 5xx / 429 / network errors
+            with exponential backoff. Default 3.
+        user_agent_suffix: Appended to the default User-Agent. Useful for
+            attribution from your own app.
+        default_headers: Extra headers merged into every request.
+    """
+
+    def __init__(
+        self,
+        *,
+        base_url: str = _http.DEFAULT_BASE_URL,
+        api_key: str | None = None,
+        timeout: float = _http.DEFAULT_TIMEOUT,
+        max_retries: int = _http.DEFAULT_MAX_RETRIES,
+        user_agent_suffix: str | None = None,
+        default_headers: Mapping[str, str] | None = None,
+    ) -> None:
+        self.base_url = base_url
+        self.api_key = api_key
+        self.timeout = timeout
+        self.max_retries = max_retries
+
+        headers: dict[str, str] = {}
+        if default_headers:
+            headers.update(default_headers)
+        if api_key:
+            headers["Authorization"] = f"Bearer {api_key}"
+        if user_agent_suffix:
+            headers["User-Agent"] = f"{_http.USER_AGENT} {user_agent_suffix}"
+        self._headers = headers
+
+    # context-manager parity with AsyncClient even though there is no socket
+    # to close in the stdlib transport; lets users write the same shape of
+    # code under either client.
+    def __enter__(self) -> Client:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        self.close()
+
+    def close(self) -> None:
+        return None
+
+    def _get(self, path: str, query: Mapping[str, Any] | None = None) -> Any:
+        url = _http.build_url(self.base_url, path, query)
+        _, body, _ = _http.request_json(
+            "GET",
+            url,
+            headers=self._headers,
+            timeout=self.timeout,
+            max_retries=self.max_retries,
+        )
+        return body
+
+    # ---- system probes -------------------------------------------------
+
+    def health(self) -> dict[str, Any]:
+        body = self._get("/health")
+        return body if isinstance(body, dict) else {}
+
+    def ready(self) -> dict[str, Any]:
+        body = self._get("/ready")
+        return body if isinstance(body, dict) else {}
+
+    # ---- market data ---------------------------------------------------
+
+    def ohlcv(
+        self,
+        symbol: str,
+        exchange: str,
+        from_: str | None = None,
+        to: str | None = None,
+    ) -> list[OHLCV]:
+        """End-of-day OHLCV rows for one symbol over a date range.
+
+        Args:
+            symbol: Trading symbol, e.g. ``"RELIANCE"``. Case-insensitive.
+            exchange: ``"nse"`` or ``"bse"``. Case-insensitive.
+            from_: Inclusive start ``YYYY-MM-DD``. Defaults to ``to`` minus
+                90 days on the server.
+            to: Inclusive end ``YYYY-MM-DD``. Defaults to today (UTC) on
+                the server.
+        """
+        ex = _http.normalize_exchange(exchange)
+        sym = _http.normalize_symbol(symbol)
+        query: dict[str, str] = {}
+        if from_ is not None:
+            query["from"] = _http.validate_date(from_, "from_")
+        if to is not None:
+            query["to"] = _http.validate_date(to, "to")
+        body = self._get(f"/v1/ohlcv/{ex}/{sym}", query or None)
+        return _http.envelope_data(body)  # type: ignore[return-value]
+
+    def snapshot(self, exchange: str, date: str) -> list[SnapshotRow]:
+        """Every symbol's bhavcopy line for one trading date on one exchange."""
+        ex = _http.normalize_exchange(exchange)
+        d = _http.validate_date(date, "date")
+        body = self._get(f"/v1/snapshot/{ex}", {"date": d})
+        return _http.envelope_data(body)  # type: ignore[return-value]
+
+    def actions(self, symbol: str) -> list[Action]:
+        """All corporate actions ever recorded for one symbol."""
+        sym = _http.normalize_symbol(symbol)
+        body = self._get(f"/v1/actions/{sym}")
+        return _http.envelope_data(body)  # type: ignore[return-value]
+
+
+    # ---- free key tier -------------------------------------------------
+
+    def adjusted(
+        self,
+        symbol: str,
+        exchange: str,
+        from_: str | None = None,
+        to: str | None = None,
+    ) -> list[AdjustedRow]:
+        """Back-adjusted prices for one symbol. Needs a free API key.
+
+        Same range semantics as :meth:`ohlcv`. Adds ``adj_factor_cumulative``
+        and ``adj_close``, continuous through splits, bonuses and dividends.
+        """
+        ex = _http.normalize_exchange(exchange)
+        sym = _http.normalize_symbol(symbol)
+        body = self._get(f"/v1/adjusted/{ex}/{sym}", _range_query(from_, to))
+        return _http.envelope_data(body)  # type: ignore[return-value]
+
+    def symbols(
+        self,
+        exchange: str,
+        *,
+        symbol: str | None = None,
+        isin: str | None = None,
+    ) -> list[SymbolInterval]:
+        """Symbol history by ``symbol`` or ``isin``. Needs a free API key.
+
+        One row per contiguous run of an ISIN under a symbol.
+        """
+        if symbol is None and isin is None:
+            raise ValueError("pass symbol= or isin=")
+        ex = _http.normalize_exchange(exchange)
+        query: dict[str, str] = {}
+        if symbol is not None:
+            query["symbol"] = _http.normalize_symbol(symbol)
+        if isin is not None:
+            query["isin"] = isin.strip().upper()
+        body = self._get(f"/v1/symbols/{ex}", query)
+        return _http.envelope_data(body)  # type: ignore[return-value]
+
+    def me(self) -> dict[str, Any]:
+        """Account, keys and today's usage for the calling key."""
+        body = self._get("/v1/me")
+        return body if isinstance(body, dict) else {}
+
+    # ---- pro tier ------------------------------------------------------
+
+    def metrics(
+        self,
+        symbol: str,
+        exchange: str,
+        from_: str | None = None,
+        to: str | None = None,
+    ) -> list[MetricsRow]:
+        """Per-day derived metrics on adjusted close. Needs a Pro key.
+
+        Returns at 1/5/21/63/126/252 days and YTD, 52-week high and low with
+        distance, average volume and turnover. Rolling fields are ``None``
+        until a full window of history exists.
+        """
+        ex = _http.normalize_exchange(exchange)
+        sym = _http.normalize_symbol(symbol)
+        body = self._get(f"/v1/metrics/{ex}/{sym}", _range_query(from_, to))
+        return _http.envelope_data(body)  # type: ignore[return-value]
+
+    def universe(
+        self,
+        name: str = "liquid500",
+        exchange: str = "nse",
+        as_of: str | None = None,
+    ) -> list[UniverseMember]:
+        """Point-in-time liquidity universe. Needs a Pro key.
+
+        ``name`` is ``liquid100``, ``liquid250`` or ``liquid500``: the top N
+        by trailing 63-day turnover at the latest monthly rebalance on or
+        before ``as_of`` (default today). Delisted names stay in the months
+        they qualified for, so there is no survivorship bias.
+        """
+        n = name.strip().lower()
+        if n not in ("liquid100", "liquid250", "liquid500"):
+            raise ValueError("name must be liquid100, liquid250 or liquid500")
+        query: dict[str, str] = {"exchange": _http.normalize_exchange(exchange)}
+        if as_of is not None:
+            query["as_of"] = _http.validate_date(as_of, "as_of")
+        body = self._get(f"/v1/universe/{n}", query)
+        return _http.envelope_data(body)  # type: ignore[return-value]
+
+    def batch(
+        self,
+        symbols: Iterable[str],
+        exchange: str = "nse",
+        from_: str | None = None,
+        to: str | None = None,
+    ) -> dict[str, list[OHLCV]]:
+        """OHLCV for up to 50 symbols in one request. Needs a Pro key.
+
+        Returns a dict keyed by symbol; unknown symbols map to ``[]``.
+        """
+        syms = [_http.normalize_symbol(s) for s in symbols]
+        if not syms:
+            raise ValueError("symbols must not be empty")
+        if len(syms) > 50:
+            raise ValueError("at most 50 symbols per batch")
+        query = _range_query(from_, to) or {}
+        query["symbols"] = ",".join(syms)
+        query["exchange"] = _http.normalize_exchange(exchange)
+        body = self._get("/v1/batch", query)
+        data = body.get("data") if isinstance(body, dict) else None
+        return data if isinstance(data, dict) else {}
+
+    def resolve(
+        self,
+        q: str,
+        exchange: str = "both",
+        limit: int = 5,
+    ) -> list[ResolveHit]:
+        """Resolve free text to symbols. Needs a Pro key.
+
+        ``"Reliance Industries"``, ``"tata mot"``, ``"infosis"`` or a former
+        ticker like ``"ZOMATO"`` all resolve. Best match first, with
+        ``score`` and ``matched_on``.
+        """
+        q = q.strip()
+        if not 2 <= len(q) <= 80:
+            raise ValueError("q must be 2 to 80 characters")
+        if not 1 <= limit <= 25:
+            raise ValueError("limit must be 1 to 25")
+        ex = "both" if exchange.lower() == "both" else _http.normalize_exchange(exchange)
+        body = self._get("/v1/resolve", {"q": q, "exchange": ex, "limit": str(limit)})
+        return _http.envelope_data(body)  # type: ignore[return-value]
+
+    # ---- envelope variants (with meta) ---------------------------------
+
+    def ohlcv_envelope(
+        self,
+        symbol: str,
+        exchange: str,
+        from_: str | None = None,
+        to: str | None = None,
+    ) -> Envelope:
+        ex = _http.normalize_exchange(exchange)
+        sym = _http.normalize_symbol(symbol)
+        query: dict[str, str] = {}
+        if from_ is not None:
+            query["from"] = _http.validate_date(from_, "from_")
+        if to is not None:
+            query["to"] = _http.validate_date(to, "to")
+        body = self._get(f"/v1/ohlcv/{ex}/{sym}", query or None)
+        return cast(Envelope, body) if isinstance(body, dict) else Envelope(data=[])
+
+
+def _range_query(from_: str | None, to: str | None) -> dict[str, str] | None:
+    query: dict[str, str] = {}
+    if from_ is not None:
+        query["from"] = _http.validate_date(from_, "from_")
+    if to is not None:
+        query["to"] = _http.validate_date(to, "to")
+    return query or None

tej/exceptions.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+
+class TejError(Exception):
+    """Base exception for all tej SDK errors."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        status_code: int | None = None,
+        error_code: str | None = None,
+        request_id: str | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+        self.error_code = error_code
+        self.request_id = request_id
+
+    def __str__(self) -> str:
+        parts = [super().__str__()]
+        if self.status_code is not None:
+            parts.append(f"status={self.status_code}")
+        if self.error_code:
+            parts.append(f"error={self.error_code}")
+        if self.request_id:
+            parts.append(f"request_id={self.request_id}")
+        return " ".join(parts)
+
+
+class BadRequestError(TejError):
+    """400: invalid path or query parameter."""
+
+
+class NotFoundError(TejError):
+    """404: resource not found."""
+
+
+class AuthError(TejError):
+    """HTTP 401: no API key was sent where one is required, or the key is
+    malformed, unknown, or revoked. ``error_code`` is ``key_required`` or
+    ``invalid_key``. Get a free key at https://tejhq.dev/keys."""
+
+
+class ProRequiredError(TejError):
+    """402: endpoint is part of the Pro tier."""
+
+
+class RateLimitError(TejError):
+    """429: client exceeded rate limit."""
+
+
+class ServerError(TejError):
+    """5xx: upstream failure."""
+
+
+class NetworkError(TejError):
+    """Transport-level failure (DNS, connection, timeout, TLS)."""
+
+
+def from_status(status: int, message: str, **kwargs: object) -> TejError:
+    cls: type[TejError]
+    if status == 400:
+        cls = BadRequestError
+    elif status == 401:
+        cls = AuthError
+    elif status == 402:
+        cls = ProRequiredError
+    elif status == 404:
+        cls = NotFoundError
+    elif status == 429:
+        cls = RateLimitError
+    elif 500 <= status < 600:
+        cls = ServerError
+    else:
+        cls = TejError
+    return cls(message, status_code=status, **kwargs)  # type: ignore[arg-type]

tej/models.py

@@ -0,0 +1,134 @@
+"""Row schemas for tej-api responses.
+
+These are `TypedDict`s rather than dataclasses so that values returned by the
+SDK are plain `dict`s, usable directly with `polars.DataFrame(rows)`,
+`pandas.DataFrame(rows)`, or any other tabular library, without an extra
+conversion step.
+
+All date fields are strings formatted as ``YYYY-MM-DD`` (matching the API's
+``format: date`` declaration). Parse with ``datetime.date.fromisoformat`` or
+``polars.col("date").str.to_date()`` if you need a date object.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Literal, TypedDict
+
+Exchange = Literal["nse", "bse", "NSE", "BSE"]
+
+
+class OHLCV(TypedDict):
+    date: str
+    open: float
+    high: float
+    low: float
+    close: float
+    last: float
+    prev_close: float
+    volume: int
+    turnover: float
+    trades: int
+
+
+class SnapshotRow(TypedDict):
+    symbol: str
+    series: str
+    isin: str
+    name: str
+    open: float
+    high: float
+    low: float
+    close: float
+    last: float
+    prev_close: float
+    volume: int
+    turnover: float
+    trades: int
+
+
+class Action(TypedDict, total=False):
+    exchange: str
+    symbol: str
+    isin: str
+    company: str
+    ex_date: str
+    record_date: str | None
+    type: str
+    ratio_num: int | None
+    ratio_den: int | None
+    cash_amount: float | None
+    face_value_from: float | None
+    face_value_to: float | None
+    raw_subject: str
+
+
+class AdjustedRow(TypedDict):
+    date: str
+    open: float
+    high: float
+    low: float
+    close: float
+    volume: int
+    turnover: float
+    adj_factor_cumulative: float
+    adj_close: float
+
+
+class SymbolInterval(TypedDict):
+    isin: str
+    symbol: str
+    valid_from: str
+    valid_to: str
+    trading_days: int
+
+
+class MetricsRow(TypedDict):
+    date: str
+    isin: str
+    adj_close: float
+    ret_1d: float | None
+    ret_5d: float | None
+    ret_21d: float | None
+    ret_63d: float | None
+    ret_126d: float | None
+    ret_252d: float | None
+    ret_ytd: float | None
+    high_52w: float | None
+    low_52w: float | None
+    pct_off_52w_high: float | None
+    pct_off_52w_low: float | None
+    avg_vol_20d: float | None
+    avg_vol_60d: float | None
+    avg_turnover_20d: float | None
+
+
+class UniverseMember(TypedDict):
+    rank: int
+    symbol: str
+    isin: str
+    name: str
+    avg_turnover_63d: float
+
+
+class ResolveHit(TypedDict, total=False):
+    exchange: str
+    symbol: str
+    isin: str
+    name: str
+    score: float
+    matched_on: Literal["symbol", "former_symbol", "name", "symbol_prefix", "name_prefix", "fuzzy"]
+    former_symbols: list[str]
+
+
+class Envelope(TypedDict, total=False):
+    data: list[dict[str, Any]]
+    meta: dict[str, Any]
+
+
+__all__ = [
+    "Action",
+    "Envelope",
+    "Exchange",
+    "OHLCV",
+    "SnapshotRow",
+]

tejhq-0.2.0.dist-info/METADATA

@@ -0,0 +1,257 @@
+Metadata-Version: 2.5
+Name: tejhq
+Version: 0.2.0
+Summary: Python SDK for tej-api: open EOD market data for NSE and BSE.
+Project-URL: Homepage, https://tejhq.dev
+Project-URL: Documentation, https://tejhq.dev/docs
+Project-URL: Repository, https://github.com/tejhq/tej-sdk-py
+Project-URL: Issues, https://github.com/tejhq/tej-sdk-py/issues
+Project-URL: Changelog, https://github.com/tejhq/tej-sdk-py/blob/master/CHANGELOG.md
+Author-email: TejHQ <support@tejhq.dev>
+License: MIT
+License-File: LICENSE
+Keywords: bhavcopy,bse,india,market-data,nse,ohlcv,stocks
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+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: Programming Language :: Python :: 3.13
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Provides-Extra: pandas
+Requires-Dist: pandas>=2.0; extra == 'pandas'
+Provides-Extra: polars
+Requires-Dist: polars>=1.0; extra == 'polars'
+Description-Content-Type: text/markdown
+
+# tej
+
+[![PyPI](https://img.shields.io/pypi/v/tejhq.svg)](https://pypi.org/project/tejhq/)
+[![Python](https://img.shields.io/pypi/pyversions/tejhq.svg)](https://pypi.org/project/tejhq/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+Python SDK for [tej-api](https://api.tejhq.dev): open, free, end-of-day market data for NSE and BSE. No signup, no keys, no catch.
+
+**Zero runtime dependencies.** Sync and async clients with identical surface. Returns plain `list[dict]` rows so you can feed them straight to polars, pandas, or your own code without an extra conversion step.
+
+## Install
+
+```bash
+pip install tejhq
+```
+
+That is the entire install. No `httpx`, no `aiohttp`, no `pydantic`. Just stdlib. Distribution is `tejhq`; import as `tej`.
+
+## Quick start (sync)
+
+```python
+from tej import Client
+
+c = Client()
+
+# Last 90 days of RELIANCE (default range)
+rows = c.ohlcv("RELIANCE", "nse")
+print(rows[-1])
+# {'date': '2026-06-05', 'open': 1442.0, 'high': 1455.7, ...}
+
+# Full history since 2010
+rows = c.ohlcv("RELIANCE", "nse", "2010-01-04", "2026-06-05")
+print(len(rows))  # ~4040
+
+# Full-market snapshot for one trading date
+snap = c.snapshot("nse", "2025-05-28")
+print(len(snap))  # ~2700 symbols
+
+# Corporate actions (dividends, splits, bonuses)
+acts = c.actions("RELIANCE")
+print(acts[0])
+# {'exchange': 'NSE', 'type': 'dividend', 'ex_date': '2024-10-28', 'cash_amount': 10.0, ...}
+```
+
+## Quick start (async)
+
+```python
+import asyncio
+from tej import AsyncClient
+
+async def main():
+    async with AsyncClient() as c:
+        # Fan out 10 symbols concurrently
+        symbols = ["RELIANCE", "TCS", "INFY", "HDFCBANK", "ICICIBANK",
+                   "SBIN", "HINDUNILVR", "ITC", "LT", "AXISBANK"]
+        results = await asyncio.gather(*[c.ohlcv(s, "nse") for s in symbols])
+        for sym, rows in zip(symbols, results):
+            print(sym, len(rows))
+
+asyncio.run(main())
+```
+
+## Use with polars / pandas
+
+`tej` returns `list[dict]` so you bring your own dataframe library.
+
+```python
+import polars as pl
+from tej import Client
+
+rows = Client().ohlcv("RELIANCE", "nse", "2010-01-04", "2026-06-05")
+df = pl.DataFrame(rows)
+df = df.with_columns(pl.col("date").str.to_date())
+df.head()
+```
+
+```python
+import pandas as pd
+from tej import Client
+
+rows = Client().ohlcv("RELIANCE", "nse", "2025-01-01", "2025-06-01")
+df = pd.DataFrame(rows)
+df["date"] = pd.to_datetime(df["date"])
+df.set_index("date", inplace=True)
+df["close"].plot()
+```
+
+Optional extras install the dataframe library alongside the SDK:
+
+```bash
+pip install "tejhq[polars]"
+pip install "tejhq[pandas]"
+```
+
+## Free key endpoints
+
+Get a key at [tejhq.dev/keys](https://tejhq.dev/keys), no card, no password.
+
+```python
+from tej import Client
+
+c = Client(api_key="tej_live_...")
+
+# Back-adjusted prices, continuous through splits, bonuses and dividends
+adj = c.adjusted("RELIANCE", "nse", "2024-10-01", "2024-11-30")
+print(adj[-1]["adj_close"], adj[-1]["adj_factor_cumulative"])
+
+# Symbol history by ISIN or symbol
+c.symbols("nse", isin="INE040A01034")
+c.symbols("nse", symbol="HDFCBANK")
+
+# Account, keys, today's usage
+c.me()
+```
+
+## Pro endpoints
+
+```python
+c = Client(api_key="tej_live_...")   # a key on the Pro tier
+
+# Derived metrics per day: returns, 52w high/low, average volume and turnover
+m = c.metrics("RELIANCE", "nse", "2026-01-01")
+
+# Point-in-time liquidity universe, survivorship-bias-free
+members = c.universe("liquid500", "nse", as_of="2019-03-15")
+symbols = [x["symbol"] for x in members]
+
+# Up to 50 symbols in one request, dict keyed by symbol
+bars = c.batch(["RELIANCE", "TCS", "INFY"], "nse", "2026-01-01")
+
+# Free text to symbol
+c.resolve("tata motors", exchange="nse", limit=3)
+c.resolve("zomato")   # former ticker resolves to the current one
+```
+
+## API reference
+
+| Method | Endpoint | Tier | Returns |
+| --- | --- | --- | --- |
+| `c.ohlcv(symbol, exchange, from_=None, to=None)` | `GET /v1/ohlcv/{exchange}/{symbol}` | keyless | `list[OHLCV]` |
+| `c.snapshot(exchange, date)` | `GET /v1/snapshot/{exchange}?date=` | keyless | `list[SnapshotRow]` |
+| `c.actions(symbol)` | `GET /v1/actions/{symbol}` | keyless | `list[Action]` |
+| `c.adjusted(symbol, exchange, from_=None, to=None)` | `GET /v1/adjusted/{exchange}/{symbol}` | free key | `list[AdjustedRow]` |
+| `c.symbols(exchange, symbol=None, isin=None)` | `GET /v1/symbols/{exchange}` | free key | `list[SymbolInterval]` |
+| `c.me()` | `GET /v1/me` | free key | `dict` |
+| `c.metrics(symbol, exchange, from_=None, to=None)` | `GET /v1/metrics/{exchange}/{symbol}` | pro | `list[MetricsRow]` |
+| `c.universe(name, exchange="nse", as_of=None)` | `GET /v1/universe/{name}` | pro | `list[UniverseMember]` |
+| `c.batch(symbols, exchange="nse", from_=None, to=None)` | `GET /v1/batch` | pro | `dict[str, list[OHLCV]]` |
+| `c.resolve(q, exchange="both", limit=5)` | `GET /v1/resolve` | pro | `list[ResolveHit]` |
+| `c.health()`, `c.ready()` | `GET /health`, `GET /ready` | keyless | `dict` |
+
+Need the response envelope (with `meta`)? Use `c.ohlcv_envelope(...)`, which returns the raw `{"data": [...], "meta": {...}}` dict.
+
+`AsyncClient` exposes the same surface with `await`.
+
+## Configuration
+
+```python
+from tej import Client
+
+c = Client(
+    base_url="https://api.tejhq.dev",   # override for self-hosted or staging
+    api_key=None,                        # tej_live_... from https://tejhq.dev/keys; keyless works for ohlcv, snapshot, actions
+    timeout=30.0,                        # seconds
+    max_retries=3,                       # exponential backoff on 5xx/429/network
+    user_agent_suffix="my-app/1.0",      # for attribution
+    default_headers={"X-My-Header": "hi"},
+)
+```
+
+## Errors
+
+All errors inherit from `tej.TejError`. The specific subclass tells you what happened:
+
+| Exception | When |
+| --- | --- |
+| `BadRequestError` | HTTP 400, bad path or query parameter (also raised locally on invalid args before the request goes out, as a plain `ValueError`) |
+| `AuthError` | HTTP 401, `key_required` when no key was sent to a gated endpoint, `invalid_key` when the key is malformed, unknown, or revoked |
+| `NotFoundError` | HTTP 404 |
+| `ProRequiredError` | HTTP 402, the key's tier is too low for this endpoint (`/v1/universe`, `/v1/metrics` need Pro) |
+| `TejError` with `error_code == "key_required"` | HTTP 401, the endpoint needs a key and none was sent (`/v1/adjusted`, `/v1/symbols`) |
+| `TejError` with `error_code == "invalid_key"` | HTTP 401, the key is malformed, unknown, or revoked |
+| `RateLimitError` | HTTP 429 |
+| `ServerError` | HTTP 5xx |
+| `NetworkError` | DNS, connection, TLS, or timeout failure |
+| `TejError` | Anything else |
+
+```python
+from tej import Client, ProRequiredError
+
+try:
+    Client().ohlcv("RELIANCE", "nse")
+except ProRequiredError as e:
+    print(e.error_code)  # 'pro_required'
+    print(e.request_id)  # tej-api request id from response headers
+```
+
+## Why a separate package
+
+[tej-api](https://github.com/tejhq/tej-api) is a Go service. [tej-bazaar](https://github.com/tejhq/tej-bazaar) is the Python ingestion pipeline. This repo is the thin client that anyone can `pip install` without dragging in either, and that releases on its own cadence as the API evolves.
+
+## Coverage
+
+- **NSE bhavcopy + corp actions**: 2010-01-04 to today, ~4,047 trading days, ~7M rows
+- **BSE bhavcopy + corp actions**: 2024-07-08 to today (the SEBI CMTS cutover), ~470 days, ~1M rows
+- **Cron refresh**: weekdays 20:00 IST
+
+Keyless endpoints are served at the Cloudflare edge from pre-rendered JSON, so most requests return in well under a second and repeat requests are cache hits. Keyless access is rate limited to 100 requests per 10 seconds per IP at the edge and 120 per minute at origin; the SDK retries 429s with backoff. Keyed requests bypass the edge cache and carry `X-RateLimit-Limit-Day` and `X-RateLimit-Remaining-Day` headers: 1,000 a day and 300 a minute on a free key.
+
+## License
+
+MIT. Use it, fork it, ship products on top of it.
+
+## Links
+
+- API docs: [tejhq.dev/docs](https://tejhq.dev/docs)
+- OpenAPI spec: [api.tejhq.dev/openapi.yaml](https://api.tejhq.dev/openapi.yaml)
+- Bulk parquet downloads: [data.tejhq.dev](https://data.tejhq.dev) and [huggingface.co/datasets/tejhq/indian-markets](https://huggingface.co/datasets/tejhq/indian-markets)
+- Issues: [github.com/tejhq/tej-sdk-py/issues](https://github.com/tejhq/tej-sdk-py/issues)

tejhq-0.2.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+tej/__init__.py,sha256=cvXBc4C47jM40881gb6Pn7YRNuNXoY7-_Zre7ZTINGM,1368
+tej/_http.py,sha256=eZwE0DikjVdoGV55TWWNLk84P_F-1DzTdAMjK9BeA5Q,6881
+tej/_version.py,sha256=Zn1KFblwuFHiDRdRAiRnDBRkbPttWh44jKa5zG2ov0E,22
+tej/async_client.py,sha256=DgbLzP5LfA1wnL3kJp5ImUFm45lU1wZq7LN9tzdldNw,10636
+tej/client.py,sha256=wcYUBq1LCgi8bSYjBMTIjrFAsf5wUPgCBc-zdbe6C2w,11078
+tej/exceptions.py,sha256=wgeBni_NcYq-jfxfb2vGsrpXLp4E2_CevRB85nrDg74,2068
+tej/models.py,sha256=BxHjmUVmAmMdps5HMJiG5qv-MiWVYCKIWQUYJNvidGI,2770
+tej/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tejhq-0.2.0.dist-info/METADATA,sha256=ltpz7LtQEKMDzbqneSuKtfv8PlI2x7h-fSvo4GJ9sI0,9985
+tejhq-0.2.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+tejhq-0.2.0.dist-info/licenses/LICENSE,sha256=GqzYB0aqsY1UGrHmfen4ZuybTbp_mYRF9Ii0gyeTEPs,1062
+tejhq-0.2.0.dist-info/RECORD,,

tejhq-0.2.0.dist-info/WHEEL

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

tejhq-0.2.0.dist-info/licenses/LICENSE

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