sahiapi 0.1.0__py3-none-any.whl

sahiapi/__init__.py

@@ -0,0 +1,88 @@
+"""sahiapi — the official Python client for the Sahi APIs.
+
+The public interface lives here. Everything under :mod:`sahiapi.sahi` is
+internal and may change without notice.
+
+    from sahiapi import SahiAPI
+
+    api = SahiAPI.from_credentials(key_id="...", secret="...")
+    print(api.get_profile())
+
+The SDK mirrors the API reference at https://docs.sahi.com/ exactly: it does
+not rename fields, build models, or convert units. Money is integer paise,
+quantities are integer units, timestamps are epoch milliseconds, and identifiers
+are opaque strings.
+"""
+
+from __future__ import annotations
+
+from .sahi import constants
+from .sahi.auth import get_access_token, token_expires_at, token_scopes
+from .sahi.client import SahiAPI
+from .sahi.constants import *  # noqa: F403 -- re-export every wire constant
+from .sahi.exceptions import (
+    SahiAccountLockedException,
+    SahiAPIException,
+    SahiAuthenticationException,
+    SahiAuthorisationException,
+    SahiBadRequestException,
+    SahiBaseException,
+    SahiConfigurationException,
+    SahiConnectionException,
+    SahiFeedAuthExpiredException,
+    SahiFeedConnectionException,
+    SahiFeedException,
+    SahiFeedForbiddenException,
+    SahiFeedNotSubscribedException,
+    SahiInvalidOrderStateException,
+    SahiIpNotAllowedException,
+    SahiKeyNotApprovedException,
+    SahiNotFoundException,
+    SahiOrderNotFoundException,
+    SahiRateLimitException,
+    SahiServerException,
+    SahiTimeoutException,
+    SahiValidationException,
+)
+from .sahi.feed import SahiFeed
+
+try:  # pragma: no cover - trivial metadata lookup
+    from importlib.metadata import PackageNotFoundError, version
+
+    __version__ = version("sahiapi")
+except PackageNotFoundError:  # pragma: no cover - running from a source tree
+    __version__ = "0.0.0+unknown"
+
+__all__ = [
+    # Client and authentication
+    "SahiAPI",
+    "SahiAPIException",
+    "SahiAccountLockedException",
+    "SahiAuthenticationException",
+    "SahiAuthorisationException",
+    "SahiBadRequestException",
+    "SahiBaseException",
+    "SahiConfigurationException",
+    "SahiConnectionException",
+    "SahiFeed",
+    "SahiFeedAuthExpiredException",
+    "SahiFeedConnectionException",
+    "SahiFeedException",
+    "SahiFeedForbiddenException",
+    "SahiFeedNotSubscribedException",
+    "SahiInvalidOrderStateException",
+    "SahiIpNotAllowedException",
+    "SahiKeyNotApprovedException",
+    "SahiNotFoundException",
+    "SahiOrderNotFoundException",
+    "SahiRateLimitException",
+    "SahiServerException",
+    "SahiTimeoutException",
+    "SahiValidationException",
+    "__version__",
+    "constants",
+    "get_access_token",
+    "token_expires_at",
+    "token_scopes",
+]
+__all__ += list(constants.__all__)

sahiapi/sahi/account.py

@@ -0,0 +1,28 @@
+"""Account endpoint: profile.
+
+Mirrors the Account page of the API reference. ``get_profile`` needs the
+``profile.read`` scope. Read it once at start of day; it does not change during a
+session.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from .base import EndpointGroup
+
+__all__ = ["_Account"]
+
+
+class _Account(EndpointGroup):
+    """Account methods mixed into :class:`SahiAPI`."""
+
+    def get_profile(self, *, timeout: float | None = None) -> dict[str, Any]:
+        """Return your identity and account status (``GET /v1/profile``).
+
+        Returns:
+            ``{"user_id": ..., "name": ...}``.
+        """
+        return self._request(  # type: ignore[no-any-return]
+            "GET", "/v1/profile", timeout=timeout, retry_on_rate_limit=True
+        )

sahiapi/sahi/auth.py

@@ -0,0 +1,163 @@
+"""Authentication: minting an access token and reading what it carries.
+
+A Sahi access token is minted from an API key. You create the key in your Sahi
+account, approve it for the trading day, and exchange the key id and secret for a
+token with :func:`get_access_token`. The token is a Bearer JWT that every REST
+and WebSocket call carries, and it expires at 06:00 IST — there is no refresh, so
+mint a fresh one each trading day.
+
+The helpers here also read a token's own claims without verifying its signature,
+to tell callers when a token expires and what it is allowed to do. They are for
+information only: the SDK never refuses a request on them, and the server is
+always the authority.
+"""
+
+from __future__ import annotations
+
+import base64
+import binascii
+import json
+from datetime import datetime, timezone
+from typing import Any
+
+from . import env
+from .exceptions import HOST_AUTH, SahiConfigurationException
+from .http import HttpClient
+
+__all__ = [
+    "decode_token_payload",
+    "expiry_from_payload",
+    "get_access_token",
+    "scopes_from_payload",
+    "token_expires_at",
+    "token_scopes",
+]
+
+_TOKEN_PATH = "/api/v1/apikeys/token"
+
+
+def get_access_token(
+    key_id: str,
+    secret: str,
+    *,
+    scopes: list[str] | None = None,
+    timeout: float = 10.0,
+) -> dict[str, Any]:
+    """Exchange an API key for a short-lived access token.
+
+    Calls ``POST /api/v1/apikeys/token`` on the auth host and returns the token
+    response as-is.
+
+    Args:
+        key_id: The key id from your Sahi account.
+        secret: The secret shown once when the key was created.
+        scopes: Optional subset of the key's scopes to narrow the token to. A
+            token can only ever carry scopes the key holds. Omit it, or pass an
+            empty list, to get the key's full set.
+        timeout: Request timeout in seconds.
+
+    Returns:
+        The token response dict, unchanged: ``access_token``, ``token_type``,
+        ``expires_in``, ``expires_at`` and ``scope``.
+
+    The key id and secret are sent as given: their format is the auth server's
+    to define, so the SDK does not check it.
+
+    Raises:
+        SahiAuthenticationException: Unknown key id, wrong secret, or a revoked
+            key (401 — deliberately indistinguishable).
+        SahiAccountLockedException: The account is frozen or locked.
+        SahiKeyNotApprovedException: The key is not approved for the current
+            trading day.
+        SahiBadRequestException: A field is malformed, or ``scopes`` is not a
+            subset of the key's scopes.
+        SahiRateLimitException: Too many mint attempts; wait for the next minute.
+    """
+    body: dict[str, Any] = {"key_id": key_id, "secret": secret}
+    if scopes is not None:
+        body["scopes"] = scopes
+
+    with HttpClient(env.AUTH_BASE_URL, host=HOST_AUTH, timeout=timeout) as client:
+        result = client.request("POST", _TOKEN_PATH, json=body)
+    return result  # type: ignore[no-any-return]  # token endpoint returns a JSON object
+
+
+def decode_token_payload(access_token: str) -> dict[str, Any]:
+    """Decode a JWT's payload claims without verifying the signature.
+
+    This reads what the token asserts about itself; it does not check that the
+    assertions are trustworthy. The server verifies the signature on every call.
+
+    Raises:
+        SahiConfigurationException: If the value is not a decodable JWT.
+    """
+    parts = access_token.split(".")
+    if len(parts) != 3:
+        raise SahiConfigurationException("access token is not a well-formed JWT")
+    payload_segment = parts[1]
+    padding = "=" * (-len(payload_segment) % 4)
+    try:
+        raw = base64.urlsafe_b64decode(payload_segment + padding)
+        payload = json.loads(raw)
+    except (binascii.Error, ValueError) as e:
+        raise SahiConfigurationException("could not decode the access token payload") from e
+    if not isinstance(payload, dict):
+        raise SahiConfigurationException("access token payload is not a JSON object")
+    return payload
+
+
+def expiry_from_payload(payload: dict[str, Any]) -> datetime | None:
+    """The ``exp`` claim as a timezone-aware UTC datetime, or ``None`` if absent.
+
+    Raises:
+        SahiConfigurationException: If ``exp`` is present but is not a number
+            of epoch seconds that fits in a datetime — a token minted by
+            something other than Sahi.
+    """
+    exp = payload.get("exp")
+    if exp is None:
+        return None
+    # bool is an int subclass; a literal true/false is not an epoch time.
+    if isinstance(exp, bool) or not isinstance(exp, (int, float)):
+        raise SahiConfigurationException(
+            f"access token 'exp' claim must be epoch seconds, got {type(exp).__name__}. "
+            "Use a token minted by get_access_token()."
+        )
+    try:
+        return datetime.fromtimestamp(exp, tz=timezone.utc)
+    except (OverflowError, OSError, ValueError) as e:
+        raise SahiConfigurationException(
+            "access token 'exp' claim is out of range for an epoch time. "
+            "Use a token minted by get_access_token()."
+        ) from e
+
+
+def scopes_from_payload(payload: dict[str, Any]) -> frozenset[str]:
+    """The ``scope`` claim split on whitespace; an absent or empty claim is ``frozenset()``."""
+    scope = payload.get("scope")
+    if not scope or not isinstance(scope, str):
+        return frozenset()
+    return frozenset(scope.split())
+
+
+def token_expires_at(access_token: str) -> datetime | None:
+    """Return the token's expiry as a timezone-aware UTC datetime.
+
+    Reads the ``exp`` claim. Returns ``None`` if the token carries no ``exp``.
+
+    Raises:
+        SahiConfigurationException: If the value is not a decodable JWT, or its
+            ``exp`` is not an epoch time.
+    """
+    return expiry_from_payload(decode_token_payload(access_token))
+
+
+def token_scopes(access_token: str) -> frozenset[str]:
+    """Return the scopes the token carries, from its ``scope`` claim.
+
+    The claim is a space-separated string; an absent claim yields an empty set.
+
+    Raises:
+        SahiConfigurationException: If the value is not a decodable JWT.
+    """
+    return scopes_from_payload(decode_token_payload(access_token))

sahiapi/sahi/base.py

@@ -0,0 +1,32 @@
+"""Shared base for the per-domain endpoint groups.
+
+Each docs page maps to a mixin (``_Orders``, ``_Portfolio``, …) that lists the
+methods for that page. :class:`SahiAPI` inherits all of them, so the user sees
+one flat class while each file stays focused on a single resource. Every mixin
+subclasses :class:`EndpointGroup`, which declares the ``_request`` method the
+mixins call. :class:`SahiAPI` provides the real implementation; this base gives
+the mixins a typed reference to it and keeps them independent of the client
+module, so there is no import cycle.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+__all__ = ["EndpointGroup"]
+
+
+class EndpointGroup:
+    """Base for domain mixins. ``SahiAPI`` supplies the real ``_request``."""
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: dict[str, Any] | None = None,
+        json: Any = None,
+        timeout: float | None = None,
+        retry_on_rate_limit: bool = False,
+    ) -> Any:  # pragma: no cover - overridden by SahiAPI
+        raise NotImplementedError

sahiapi/sahi/client.py

@@ -0,0 +1,306 @@
+"""The ``SahiAPI`` client: construction, authentication and token lifecycle.
+
+``SahiAPI`` is the single entry point for the REST API. The short path is
+:meth:`SahiAPI.from_credentials`, which mints a token and returns a ready client
+in one call. When a token is minted once and shared — across processes, or a
+token cached for the day — mint it with :func:`sahiapi.get_access_token` and pass
+the whole response to the constructor. The domain methods (orders, portfolio, funds,
+account, market data, instruments) are added by mixins in their own modules; this
+module owns everything common to them: the HTTP client, the token and its
+lifecycle, and the enum constants exposed as class attributes.
+
+The client does no network I/O at construction and never refreshes a token on
+its own — tokens expire at 06:00 IST by design. When a token expires, mint a new
+one and pass it to :meth:`set_access_token`.
+"""
+
+from __future__ import annotations
+
+import os
+from collections.abc import Mapping
+from datetime import datetime
+from types import TracebackType
+from typing import Any, NamedTuple, Union
+
+from . import auth, constants, env
+from .account import _Account
+from .exceptions import HOST_API, SahiConfigurationException
+from .funds import _Funds
+from .http import HttpClient
+from .instruments import _Instruments
+from .marketdata import _MarketData
+from .orders import _Orders
+from .portfolio import _Portfolio
+
+__all__ = ["SahiAPI"]
+
+_ENV_SCRIP_MASTER_URL = "SAHI_SCRIP_MASTER_URL"
+
+#: What the client accepts as a token: the response dict from
+#: :func:`get_access_token`, or just its ``access_token`` string.
+Token = Union[str, Mapping[str, Any]]
+
+
+class _TokenState(NamedTuple):
+    """Everything the client knows about its current token, published as one value."""
+
+    access_token: str
+    expires_at: datetime | None
+    scopes: frozenset[str]
+
+
+def _token_state(access_token: str) -> _TokenState:
+    """Read the claims the client reports, when it can. The parsing lives in ``auth``.
+
+    The token's format is the server's to change. A token the SDK cannot read is
+    still used as given: it just reports no expiry and no scopes.
+    """
+    try:
+        payload = auth.decode_token_payload(access_token)
+        return _TokenState(
+            access_token,
+            auth.expiry_from_payload(payload),
+            auth.scopes_from_payload(payload),
+        )
+    except SahiConfigurationException:
+        return _TokenState(access_token, None, frozenset())
+
+
+def _access_token_of(token: Token, where: str) -> str:
+    """Accept the token response or a bare token string.
+
+    Taking the whole response keeps the ``access_token`` field an implementation
+    detail of the auth API rather than something every caller must know about.
+    """
+    if isinstance(token, Mapping):
+        value = token.get("access_token")
+        if not isinstance(value, str) or not value:
+            raise SahiConfigurationException(
+                f"{where} was given a dict without an 'access_token' field. Pass the "
+                "response of get_access_token() as-is."
+            )
+        token = value
+    if not isinstance(token, str):
+        raise SahiConfigurationException(
+            f"{where} expects the token response from get_access_token() or its "
+            f"access_token string, not {type(token).__name__}."
+        )
+    return token
+
+
+class SahiAPI(_Orders, _Portfolio, _Funds, _Account, _MarketData, _Instruments):
+    """Client for the Sahi REST API.
+
+    Args:
+        token: The response of :func:`sahiapi.get_access_token` (preferred), or
+            just its ``access_token`` string. Use :meth:`from_credentials` to go
+            straight from an API key to a client.
+        scrip_master_url: The scrip-master CSV download URL, needed for the
+            instrument lookups. Defaults to ``$SAHI_SCRIP_MASTER_URL``. The URL
+            is not in the public docs; it is provided when your API access is set
+            up.
+        timeout: Default per-request timeout in seconds.
+
+    The enum values the API uses are available as class attributes, e.g.
+    ``SahiAPI.EXCHANGE_SEGMENT_NSE`` and ``SahiAPI.ORDER_TYPE_LIMIT``.
+
+    Every method returns the parsed response body unchanged and raises a subclass
+    of :class:`~sahiapi.SahiAPIException` for any non-2xx reply. Each exception
+    carries the HTTP ``status``, the server ``code`` and ``message``, a
+    ``request_id`` to quote to support, and a ``hint`` saying what to do; its
+    ``str()`` includes all of them. Catch the specific subclass you can act on
+    (:class:`~sahiapi.SahiAuthenticationException`,
+    :class:`~sahiapi.SahiRateLimitException`, …) and let the rest propagate.
+    """
+
+    # -- exchange segments --
+    EXCHANGE_SEGMENT_NSE = constants.EXCHANGE_SEGMENT_NSE
+    EXCHANGE_SEGMENT_NFO = constants.EXCHANGE_SEGMENT_NFO
+    EXCHANGE_SEGMENT_BSE = constants.EXCHANGE_SEGMENT_BSE
+    EXCHANGE_SEGMENT_BFO = constants.EXCHANGE_SEGMENT_BFO
+    EXCHANGE_SEGMENT_MCX = constants.EXCHANGE_SEGMENT_MCX
+    EXCHANGE_SEGMENT_NCOM = constants.EXCHANGE_SEGMENT_NCOM
+    # -- transaction type --
+    TXN_TYPE_BUY = constants.TXN_TYPE_BUY
+    TXN_TYPE_SELL = constants.TXN_TYPE_SELL
+    # -- order type --
+    ORDER_TYPE_LIMIT = constants.ORDER_TYPE_LIMIT
+    ORDER_TYPE_MARKET = constants.ORDER_TYPE_MARKET
+    ORDER_TYPE_SL_LIMIT = constants.ORDER_TYPE_SL_LIMIT
+    ORDER_TYPE_SL_MARKET = constants.ORDER_TYPE_SL_MARKET
+    # -- product --
+    PRODUCT_DELIVERY = constants.PRODUCT_DELIVERY
+    PRODUCT_INTRADAY = constants.PRODUCT_INTRADAY
+    PRODUCT_NORMAL = constants.PRODUCT_NORMAL
+    # -- validity --
+    VALIDITY_DAY = constants.VALIDITY_DAY
+    VALIDITY_IOC = constants.VALIDITY_IOC
+    # -- variant --
+    VARIANT_REGULAR = constants.VARIANT_REGULAR
+    VARIANT_AMO = constants.VARIANT_AMO
+    # -- order status --
+    ORDER_STATUS_OPEN = constants.ORDER_STATUS_OPEN
+    ORDER_STATUS_OPEN_PARTIAL = constants.ORDER_STATUS_OPEN_PARTIAL
+    ORDER_STATUS_PARTIAL_FILLED = constants.ORDER_STATUS_PARTIAL_FILLED
+    ORDER_STATUS_COMPLETED = constants.ORDER_STATUS_COMPLETED
+    ORDER_STATUS_CANCELLED = constants.ORDER_STATUS_CANCELLED
+    ORDER_STATUS_REJECTED = constants.ORDER_STATUS_REJECTED
+    # -- candle sizes --
+    CANDLE_1M = constants.CANDLE_1M
+    CANDLE_3M = constants.CANDLE_3M
+    CANDLE_5M = constants.CANDLE_5M
+    CANDLE_15M = constants.CANDLE_15M
+    CANDLE_30M = constants.CANDLE_30M
+    CANDLE_1H = constants.CANDLE_1H
+    CANDLE_1D = constants.CANDLE_1D
+    # -- tick-stream modes --
+    MODE_LTP = constants.MODE_LTP
+    MODE_QUOTE = constants.MODE_QUOTE
+    MODE_DEPTH = constants.MODE_DEPTH
+    # -- scopes --
+    SCOPE_ORDERS_WRITE = constants.SCOPE_ORDERS_WRITE
+    SCOPE_ORDERS_READ = constants.SCOPE_ORDERS_READ
+    SCOPE_POSITIONS_READ = constants.SCOPE_POSITIONS_READ
+    SCOPE_HOLDINGS_READ = constants.SCOPE_HOLDINGS_READ
+    SCOPE_FUNDS_READ = constants.SCOPE_FUNDS_READ
+    SCOPE_PROFILE_READ = constants.SCOPE_PROFILE_READ
+    SCOPE_MARKETDATA_READ = constants.SCOPE_MARKETDATA_READ
+    # -- tick-stream instrument types --
+    INSTRUMENT_TYPE_ETF = constants.INSTRUMENT_TYPE_ETF
+    INSTRUMENT_TYPE_INDEX = constants.INSTRUMENT_TYPE_INDEX
+    INSTRUMENT_TYPE_INDEX_FUT = constants.INSTRUMENT_TYPE_INDEX_FUT
+    INSTRUMENT_TYPE_INDEX_OPT_CE = constants.INSTRUMENT_TYPE_INDEX_OPT_CE
+    INSTRUMENT_TYPE_INDEX_OPT_PE = constants.INSTRUMENT_TYPE_INDEX_OPT_PE
+    INSTRUMENT_TYPE_STOCK = constants.INSTRUMENT_TYPE_STOCK
+    INSTRUMENT_TYPE_STOCK_FUT = constants.INSTRUMENT_TYPE_STOCK_FUT
+    INSTRUMENT_TYPE_STOCK_OPT_CE = constants.INSTRUMENT_TYPE_STOCK_OPT_CE
+    INSTRUMENT_TYPE_STOCK_OPT_PE = constants.INSTRUMENT_TYPE_STOCK_OPT_PE
+    # -- WebSocket close codes --
+    WS_CLOSE_AUTH_EXPIRED = constants.WS_CLOSE_AUTH_EXPIRED
+    WS_CLOSE_DROPPED = constants.WS_CLOSE_DROPPED
+    WS_CLOSE_FORBIDDEN = constants.WS_CLOSE_FORBIDDEN
+    WS_CLOSE_HEARTBEAT = constants.WS_CLOSE_HEARTBEAT
+    WS_CLOSE_TOO_MANY = constants.WS_CLOSE_TOO_MANY
+
+    def __init__(
+        self,
+        token: Token,
+        *,
+        scrip_master_url: str | None = None,
+        timeout: float = 10.0,
+    ) -> None:
+        access_token = _access_token_of(token, "SahiAPI()")
+        state = _token_state(access_token)
+        self._http = HttpClient(
+            env.API_BASE_URL, host=HOST_API, access_token=access_token, timeout=timeout
+        )
+        self._scrip_master_url = scrip_master_url or os.environ.get(_ENV_SCRIP_MASTER_URL)
+        self._token = state
+
+    # -- authentication -------------------------------------------------------
+
+    @classmethod
+    def from_credentials(
+        cls,
+        key_id: str,
+        secret: str,
+        *,
+        scopes: list[str] | None = None,
+        scrip_master_url: str | None = None,
+        timeout: float = 10.0,
+    ) -> SahiAPI:
+        """Mint a token and return a ready client in one call.
+
+        This is the usual entry point: the token never has to be handled by the
+        caller. It performs one request to the auth host and raises the same
+        exceptions as :func:`sahiapi.get_access_token` (not approved today, wrong
+        secret, …). Use :func:`sahiapi.get_access_token` plus the constructor
+        instead when one token must be shared or cached.
+
+        Args:
+            key_id: The key id from your Sahi account.
+            secret: The secret shown once at key creation.
+            scopes: Optional subset of the key's scopes to narrow the token to.
+            scrip_master_url: Scrip-master CSV URL (default ``$SAHI_SCRIP_MASTER_URL``).
+            timeout: Default per-request timeout in seconds, also used for the mint.
+        """
+        token = auth.get_access_token(key_id, secret, scopes=scopes, timeout=timeout)
+        return cls(token, scrip_master_url=scrip_master_url, timeout=timeout)
+
+    def set_access_token(self, token: Token) -> None:
+        """Swap in a freshly minted token for daily rotation.
+
+        Accepts the same forms as the constructor. Reuses the client and its
+        connection pool; any open :class:`SahiFeed` is untouched and keeps the
+        token it was started with.
+
+        The header is swapped and the expiry and scopes published together as
+        one value, so no request ever sees a half-updated token.
+        """
+        access_token = _access_token_of(token, "set_access_token()")
+        state = _token_state(access_token)
+        self._http.set_access_token(access_token)
+        self._token = state
+
+    @property
+    def token_expires_at(self) -> datetime | None:
+        """When the current token expires (UTC), or ``None`` if it carries no readable ``exp``."""
+        return self._token.expires_at
+
+    @property
+    def scopes(self) -> frozenset[str]:
+        """The scopes the current token carries; empty if its claims cannot be read."""
+        return self._token.scopes
+
+    @property
+    def access_token(self) -> str:
+        """The bearer token string in use, as :class:`~sahiapi.SahiFeed` borrows it.
+
+        Read-only: rotate it with :meth:`set_access_token`. A feed copies the
+        value when it is built and keeps it until stopped.
+        """
+        return self._token.access_token
+
+    # -- lifecycle ------------------------------------------------------------
+
+    def close(self) -> None:
+        """Close the underlying HTTP connection pool."""
+        self._http.close()
+
+    def __enter__(self) -> SahiAPI:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        self.close()
+
+    # -- request plumbing (used by the domain mixins) -------------------------
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: dict[str, Any] | None = None,
+        json: Any = None,
+        timeout: float | None = None,
+        retry_on_rate_limit: bool = False,
+    ) -> Any:
+        """Send a request with the current token.
+
+        Expiry is not checked locally: this host's clock can drift, and the
+        server is the authority. An expired token comes back as a ``401`` and
+        raises :class:`~sahiapi.SahiAuthenticationException` like any other.
+        """
+        return self._http.request(
+            method,
+            path,
+            params=params,
+            json=json,
+            timeout=timeout,
+            retry_on_rate_limit=retry_on_rate_limit,
+        )