Client classes

from ssi_sdk import Auth, Config

config = Config(
    client_id="<CLIENT_ID>",
    api_key="<API_KEY>",
    api_secret="<API_SECRET>",
    private_key="<PRIVATE_KEY_CONTENT>",
)

with Auth(config) as auth:
    # Xác thực với OTP
    token = auth.authenticate(otp="<OTP>")
    print(f"Expires at: {token.expires_at}")

# Yêu cầu gửi OTP (trả về dict thô)
result = auth.request_otp()

# Như trên nhưng trả về OTPResponse(message, transaction_id)
otp = auth.request_otp_typed()

# Xác thực với OTP
token = auth.authenticate(otp="<OTP>")

# Làm mới token
token = auth.refresh()

# Tự động refresh nếu token hết hạn, hoặc xác thực nếu cần
access_token = auth.ensure_authenticated(otp="<OTP>")

from ssi_sdk.exceptions import (
    ReauthenticationRequired,
    SmartOTPPendingError,
    SmartOTPRejectedError,
)

# Bước 1: gửi yêu cầu duyệt, nhận transaction_id
otp = auth.request_otp_typed()

# Bước 2: SDK tự poll cho đến khi user bấm duyệt trên app Smart OTP
try:
    access_token = auth.ensure_authenticated(
        transaction_id=otp.transaction_id,
        poll_interval_ms=5000,   # mili giây giữa mỗi lần poll (mặc định Config.otp_poll_interval_ms = 5000)
        poll_max_retries=12,     # số lần poll tối đa (mặc định suy ra từ Config.otp_poll_max_wait_ms = 60000)
    )
except SmartOTPPendingError:
    # Chưa duyệt kịp: gọi lại với cùng transaction_id
    ...
except SmartOTPRejectedError:
    # Bị từ chối / hết hạn: yêu cầu OTP mới
    ...
except ReauthenticationRequired:
    # Không refresh được: xác thực lại bằng OTP mới
    ...

print(auth.token)              # Token object hoặc None
# auth.access_token             # Access token string hoặc None (không in/log)
print(auth.is_token_expired)   # True/False
print(auth.has_refresh_token)  # True/False

from ssi_sdk import Auth, Data, Config

with Auth(config) as auth:
    auth.authenticate()  # Không cần OTP cho market data

    with Data(auth) as data:
        # Truy cập qua service
        ohlc = data.market_data.get_ohlc_1minute("SSI")
        indices = data.market_data.get_indexes()
        info = data.market_data.get_securities_info("SSI")

from ssi_sdk import Auth, Trading, Config
from ssi_sdk.enums import OrderSide

with Auth(config) as auth:
    auth.authenticate(otp="<OTP>")

    with Trading(auth) as trading:
        # Tài khoản
        accounts = trading.account.get_account_info()

        # Danh mục (có thể trả về None khi tài khoản chưa có dữ liệu)
        balance = trading.portfolio.get_equity_balance("<EQUITY_ACCOUNT_NO>")
        positions = trading.portfolio.get_equity_positions("<EQUITY_ACCOUNT_NO>")
        orders = trading.portfolio.get_today_orders("<EQUITY_ACCOUNT_NO>")

        # Giao dịch
        result = trading.trading.place_limit_order(
            account_no="<EQUITY_ACCOUNT_NO>",
            symbol="SSI",
            side=OrderSide.BUY,
            quantity=100,
            price=66000,
        )

from ssi_sdk import Auth, Stream, Config

with Auth(config) as auth:
    auth.authenticate(otp="<OTP>")

    with Stream(auth) as stream:
        # Đăng ký callback TRƯỚC khi connect
        stream.streaming.on_data = lambda msg: print(f"Data: {msg}")
        stream.streaming.on_trading = lambda msg: print(f"Trading: {msg}")
        stream.streaming.on_connection = lambda ev: print(f"Conn: {ev.state}")

        stream.streaming.connect()

        # Subscribe
        stream.streaming.subscribe_symbol(["SSI", "HPG"])
        stream.streaming.subscribe_order_status()

        # Chờ nhận dữ liệu (mili giây; bỏ trống = chờ đến khi đóng)
        stream.streaming.wait(timeout_ms=30_000)

from ssi_sdk import Auth, Config, TradingWSError, trading_ws

with Auth(config) as auth:
    auth.ensure_authenticated(otp="<OTP>")

    try:
        ws = trading_ws(auth)
    except TradingWSError as e:
        raise SystemExit(f"Server từ chối kết nối: {e}")

    try:
        book = ws.query_order_book("<EQUITY_ACCOUNT_NO>", page_size=10)
        print(book.status)
    finally:
        ws.close()  # luôn đóng socket

import asyncio
from ssi_sdk import AsyncAuth, AsyncData, AsyncTrading, AsyncStream, Config

async def main():
    config = Config(
        client_id="<CLIENT_ID>",
        api_key="<API_KEY>",
        api_secret="<API_SECRET>",
        private_key="<PRIVATE_KEY_CONTENT>",
    )

    async with AsyncAuth(config) as auth:
        await auth.authenticate(otp="<OTP>")

        async with AsyncData(auth) as data:
            ohlc = await data.market_data.get_ohlc_1minute("SSI")
            print(ohlc)

        async with AsyncTrading(auth) as trading:
            accounts = await trading.account.get_account_info()
            print(accounts)

        async with AsyncStream(auth) as stream:
            stream.streaming.on_data = lambda msg: print(msg)
            await stream.streaming.connect()
            await stream.streaming.subscribe_symbol_trade(["SSI"])
            await stream.streaming.wait(timeout_ms=30_000)

asyncio.run(main())