dnse-sdk-openapi 0.0.1__py3-none-any.whl

trading-api/send_email_otp.py

@@ -0,0 +1,22 @@
+#!/usr/bin/env python3
+import os
+import sys
+
+sys.path.append(os.path.dirname(os.path.dirname(__file__)))
+
+from dnse import DNSEClient
+
+
+def main():
+    client = DNSEClient(
+        api_key="replace-with-api-key",
+        api_secret="replace-with-api-secret",
+        base_url="https://openapi.dnse.com.vn",
+    )
+
+    status, body = client.send_email_otp(dry_run=False)
+    print(status, body)
+
+
+if __name__ == "__main__":
+    main()

websocket-marketdata/expected_price.py

@@ -0,0 +1,53 @@
+"""
+Market data subscription example.
+
+Demonstrates:
+- Subscribing to expected price updates
+
+This example shows how to receive real-time market data for multiple symbols.
+"""
+
+import asyncio
+from datetime import datetime
+
+from trading_websocket import TradingClient
+from trading_websocket.models import ExpectedPrice
+
+
+async def main():
+    # Initialize client
+    encoding = "msgpack"  # json or msgpack
+    client = TradingClient(
+        api_key="api-key",
+        api_secret="api-secret",
+        base_url="wss://ws-openapi.dnse.com.vn",
+        encoding=encoding,
+    )
+
+    def handle_expected_price(expected_price: ExpectedPrice):
+        received_at = datetime.fromtimestamp(expected_price.receivedAt).strftime("%H:%M:%S.%f")[:-3] if expected_price.receivedAt else "N/A"
+        print(f"[{received_at}] EXPECTED PRICE: {expected_price}")
+
+    # Connect to gateway
+    print("Connecting to WebSocket gateway...")
+    await client.connect()
+    print(f"Connected! Session ID: {client._session_id}\n")
+
+    print("Subscribing to expected price for SSI and 41I1G4000...")
+    await client.subscribe_expected_price(["SSI", "41I1G4000"],
+                                          on_expected_price=handle_expected_price, encoding=encoding, board_id="G1")
+
+    print("\nReceiving market data (will run for 1 hour)...\n")
+
+    # Run for 1H to collect data
+    # In a real application, you might run indefinitely or until a specific condition
+    await asyncio.sleep(60 * 60 * 8)
+
+    # Disconnect gracefully
+    print("\n\nDisconnecting...")
+    await client.disconnect()
+    print("Disconnected!")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

websocket-marketdata/foreign_investor.py

@@ -0,0 +1,51 @@
+"""
+Demonstrates:
+- Subscribing to foreigner trading
+
+This example shows how to receive real-time foreigner trading data
+"""
+
+import asyncio
+from datetime import datetime
+
+from trading_websocket import TradingClient
+from trading_websocket.models import ForeignInvestor
+
+
+async def main():
+    # Initialize client
+    encoding = "json"  # json or msgpack
+    client = TradingClient(
+        api_key="api-key",
+        api_secret="api-secret",
+        base_url="wss://ws-openapi.dnse.com.vn",
+        encoding=encoding,
+    )
+
+    def handle_foreign_trading(data: ForeignInvestor):
+        received_at = datetime.fromtimestamp(data.receivedAt).strftime("%H:%M:%S.%f")[:-3] if data.receivedAt else "N/A"
+        print(f"[{received_at}] Foreign trading: {data}")
+
+    # Connect to gateway
+    print("Connecting to WebSocket gateway...")
+    await client.connect()
+    print(f"Connected! Session ID: {client._session_id}\n")
+
+    print("Subscribing to foreigner trading...")
+    await client.subscribe_foreign_trading(["HPG", "FPT"], board_id="G1", on_trade=handle_foreign_trading,
+                                           encoding=encoding)
+
+    print("\nReceiving foreigner trading data (will run for 8 hour)...\n")
+
+    # Run for 8H to collect data
+    # In a real application, you might run indefinitely or until a specific condition
+    await asyncio.sleep(60 * 60 * 8)
+
+    # Disconnect gracefully
+    print("\n\nDisconnecting...")
+    await client.disconnect()
+    print("Disconnected!")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

websocket-marketdata/market_index.py

@@ -0,0 +1,52 @@
+"""
+Market index subscription example.
+
+Demonstrates:
+- Subscribing to market index
+
+This example shows how to receive real-time market index
+"""
+
+import asyncio
+
+from trading_websocket import TradingClient
+from trading_websocket.models import MarketIndex
+from datetime import datetime
+
+
+async def main():
+    # Initialize client
+    encoding = "msgpack"  # json or msgpack
+    client = TradingClient(
+        api_key="api-key",
+        api_secret="api-secret",
+        base_url="wss://ws-openapi.dnse.com.vn",
+        encoding=encoding,
+    )
+
+    def handle_market_index(data: MarketIndex):
+        received_at = datetime.fromtimestamp(data.receivedAt).strftime("%H:%M:%S.%f")[:-3] if data.receivedAt else "N/A"
+        print(f"[{received_at}] Market index: {data}")
+
+    # Connect to gateway
+    print("Connecting to WebSocket gateway...")
+    await client.connect()
+    print(f"Connected! Session ID: {client._session_id}\n")
+
+    print("Subscribing to market index...")
+    await client.subscribe_market_index(market_index='HNX', on_market_index=handle_market_index, encoding=encoding)
+
+    print("\nReceiving market index (will run for 1 hour)...\n")
+
+    # Run for 1H to collect data
+    # In a real application, you might run indefinitely or until a specific condition
+    await asyncio.sleep(8 * 60 * 60)
+
+    # Disconnect gracefully
+    print("\n\nDisconnecting...")
+    await client.disconnect()
+    print("Disconnected!")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

websocket-marketdata/ohlc.py

@@ -0,0 +1,55 @@
+"""
+Market data subscription example.
+
+Demonstrates:
+- Subscribing to OHLCV updates
+
+This example shows how to receive real-time market data for multiple symbols.
+"""
+
+import asyncio
+from datetime import datetime
+
+from trading_websocket import TradingClient
+from trading_websocket.models import Ohlc
+
+
+async def main():
+    # Initialize client
+    encoding = "msgpack"  # json or msgpack
+    client = TradingClient(
+        api_key="api-key",
+        api_secret="api-secret",
+        base_url="wss://ws-openapi.dnse.com.vn",
+        encoding=encoding,
+    )
+
+    def handle_ohlc(ohlc: Ohlc):
+        received_at = datetime.fromtimestamp(ohlc.receivedAt).strftime("%H:%M:%S.%f")[:-3] if ohlc.receivedAt else "N/A"
+        print(f"[{received_at}] OHLC: {ohlc}")
+
+    # Connect to gateway
+    print("Connecting to WebSocket gateway...")
+    await client.connect()
+    print(f"Connected! Session ID: {client._session_id}\n")
+
+    print("Subscribing to ohlc for SSI, VN30F1M and VN30...")
+    # internal 1 3 5 15 30 1H 1D 1W
+    await client.subscribe_ohlc(["SSI", "VN30F1M", "VN30"], resolution="1", on_ohlc=handle_ohlc, encoding=encoding)
+
+    # Subscribe to 1-minute OHLC
+
+    print("\nReceiving market data (will run for 1 hour)...\n")
+
+    # Run for 8H to collect data
+    # In a real application, you might run indefinitely or until a specific condition
+    await asyncio.sleep(8 * 60 * 60)
+
+    # Disconnect gracefully
+    print("\n\nDisconnecting...")
+    await client.disconnect()
+    print("Disconnected!")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

websocket-marketdata/ohlc_closed.py

@@ -0,0 +1,55 @@
+"""
+Market data subscription example.
+
+Demonstrates:
+- Subscribing to OHLCV updates
+
+This example shows how to receive real-time market data for multiple symbols.
+"""
+
+import asyncio
+from datetime import datetime
+
+from trading_websocket import TradingClient
+from trading_websocket.models import Ohlc
+
+
+async def main():
+    # Initialize client
+    encoding = "msgpack"  # json or msgpack
+    client = TradingClient(
+        api_key="api-key",
+        api_secret="api-secret",
+        base_url="wss://ws-openapi.dnse.com.vn",
+        encoding=encoding,
+    )
+
+    def handle_ohlc(ohlc: Ohlc):
+        received_at = datetime.fromtimestamp(ohlc.receivedAt).strftime("%H:%M:%S.%f")[:-3] if ohlc.receivedAt else "N/A"
+        print(f"[{received_at}] OHLC: {ohlc}")
+
+    # Connect to gateway
+    print("Connecting to WebSocket gateway...")
+    await client.connect()
+    print(f"Connected! Session ID: {client._session_id}\n")
+
+    print("Subscribing to ohlc closed for SSI, VN30F1M and VN30...")
+    # internal 1 3 5 15 30 1H 1D 1W
+    await client.subscribe_ohlc_closed(["SSI", "VN30F1M", "VN30"], resolution="1", on_ohlc=handle_ohlc, encoding=encoding)
+
+    # Subscribe to 1-minute OHLC
+
+    print("\nReceiving market data (will run for 1 hour)...\n")
+
+    # Run for 8H to collect data
+    # In a real application, you might run indefinitely or until a specific condition
+    await asyncio.sleep(8 * 60 * 60)
+
+    # Disconnect gracefully
+    print("\n\nDisconnecting...")
+    await client.disconnect()
+    print("Disconnected!")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

websocket-marketdata/order.py

@@ -0,0 +1,51 @@
+"""
+Order event subscription example.
+
+This example shows how to receive real-time order event for stock and derivative orders
+"""
+
+import asyncio
+from datetime import datetime
+
+from trading_websocket import TradingClient
+from trading_websocket.models import Order
+
+
+async def main():
+    # Initialize client
+    encoding = "json"  # json or msgpack
+    client = TradingClient(
+        api_key="api-key",
+        api_secret="api-secret",
+        base_url="wss://ws-openapi.dnse.com.vn",
+        encoding=encoding,
+    )
+
+    def handle_order(data: Order):
+        received_at = datetime.fromtimestamp(data.receivedAt).strftime("%H:%M:%S.%f")[:-3] if data.receivedAt else "N/A"
+        print(f"[{received_at}] Order: {data}")
+
+    # Connect to gateway
+    print("Connecting to WebSocket gateway...")
+    await client.connect()
+    print(f"Connected! Session ID: {client._session_id}\n")
+
+    print("Subscribing to order event")
+    # market_type: DERIVATIVE | STOCK
+    await client.subscribe_order_event(market_type="STOCK",
+                                       on_order_event=handle_order, encoding=encoding)
+
+    print("\nReceiving order event (will run for 1 hour)...\n")
+
+    # Run for 8H to collect data
+    # In a real application, you might run indefinitely or until a specific condition
+    await asyncio.sleep(8 * 60 * 60)
+
+    # Disconnect gracefully
+    print("\n\nDisconnecting...")
+    await client.disconnect()
+    print("Disconnected!")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

websocket-marketdata/quote.py

@@ -0,0 +1,50 @@
+"""
+Demonstrates:
+- Subscribing to quote (BBO) updates
+
+This example shows how to receive real-time quote data for multiple symbols.
+"""
+
+import asyncio
+from datetime import datetime
+
+from trading_websocket import TradingClient
+from trading_websocket.models import Quote
+
+
+async def main():
+    # Initialize client
+    encoding = "msgpack"  # json or msgpack
+    client = TradingClient(
+        api_key="api-key",
+        api_secret="api-secret",
+        base_url="wss://ws-openapi.dnse.com.vn",
+        encoding=encoding,
+    )
+
+    def handle_quote(quote: Quote):
+        received_at = datetime.fromtimestamp(quote.receivedAt).strftime("%H:%M:%S.%f")[:-3] if quote.receivedAt else "N/A"
+        print(f"[{received_at}] QUOTE: {quote}")
+
+    # Connect to gateway
+    print("Connecting to WebSocket gateway...")
+    await client.connect()
+    print(f"Connected! Session ID: {client._session_id}\n")
+
+    print("Subscribing to quotes for SSI and 41I1G4000...")
+    await client.subscribe_quotes(["SSI", "41I1G4000"], on_quote=handle_quote, encoding=encoding, board_id="G1")
+
+    print("\nReceiving market data (will run for 1 hour)...\n")
+
+    # Run for 8H to collect data
+    # In a real application, you might run indefinitely or until a specific condition
+    await asyncio.sleep(8 * 60 * 60)
+
+    # Disconnect gracefully
+    print("\n\nDisconnecting...")
+    await client.disconnect()
+    print("Disconnected!")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

websocket-marketdata/sec_def.py

@@ -0,0 +1,52 @@
+"""
+Market data subscription example.
+
+Demonstrates:
+- Subscribing to security definition updates
+
+This example shows how to receive real-time market data for multiple symbols.
+"""
+
+import asyncio
+from datetime import datetime
+
+from trading_websocket import TradingClient
+from trading_websocket.models import SecurityDefinition
+
+
+async def main():
+    # Initialize client
+    encoding = "msgpack"  # json or msgpack
+    client = TradingClient(
+        api_key="api-key",
+        api_secret="api-secret",
+        base_url="wss://ws-openapi.dnse.com.vn",
+        encoding=encoding,
+    )
+
+    def handle_security_definition(sec_def: SecurityDefinition):
+        received_at = datetime.fromtimestamp(sec_def.receivedAt).strftime("%H:%M:%S.%f")[:-3] if sec_def.receivedAt else "N/A"
+        print(f"[{received_at}] SECURITY DEFINITION: {sec_def}")
+
+    # Connect to gateway
+    print("Connecting to WebSocket gateway...")
+    await client.connect()
+    print(f"Connected! Session ID: {client._session_id}\n")
+
+    print("Subscribing to security definition for SSI and 41I1G2000...")
+    await client.subscribe_sec_def(["SSI", "41I1G2000"], on_sec_def=handle_security_definition, encoding=encoding, board_id="G1")
+
+    print("\nReceiving market data (will run for 1 hour)...\n")
+
+    # Run for 1H to collect data
+    # In a real application, you might run indefinitely or until a specific condition
+    await asyncio.sleep(8 * 60 * 60)
+
+    # Disconnect gracefully
+    print("\n\nDisconnecting...")
+    await client.disconnect()
+    print("Disconnected!")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

websocket-marketdata/trade.py

@@ -0,0 +1,52 @@
+"""
+Market data subscription example.
+
+Demonstrates:
+- Subscribing to trade updates
+
+This example shows how to receive real-time market data for multiple symbols.
+"""
+
+import asyncio
+from datetime import datetime
+
+from trading_websocket import TradingClient
+from trading_websocket.models import Trade
+
+
+async def main():
+    # Initialize client
+    encoding = "msgpack"  # json or msgpack
+    client = TradingClient(
+        api_key="api-key",
+        api_secret="api-secret",
+        base_url="wss://ws-openapi.dnse.com.vn",
+        encoding=encoding,
+    )
+
+    def handle_trade(trade: Trade):
+        received_at = datetime.fromtimestamp(trade.receivedAt).strftime("%H:%M:%S.%f")[:-3] if trade.receivedAt else "N/A"
+        print(f"[{received_at}] TRADE: {trade}")
+
+    # Connect to gateway
+    print("Connecting to WebSocket gateway...")
+    await client.connect()
+    print(f"Connected! Session ID: {client._session_id}\n")
+
+    print("Subscribing to trades for SSI and 41I1G4000...")
+    await client.subscribe_trades(["SSI", "41I1G4000"], on_trade=handle_trade, encoding=encoding, board_id="G1")
+
+    print("\nReceiving market data (will run for 1 hour)...\n")
+
+    # Run for 8H to collect data
+    # In a real application, you might run indefinitely or until a specific condition
+    await asyncio.sleep(8 * 60 * 60)
+
+    # Disconnect gracefully
+    print("\n\nDisconnecting...")
+    await client.disconnect()
+    print("Disconnected!")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

websocket-marketdata/trade_extra.py

@@ -0,0 +1,51 @@
+"""
+Market data subscription example.
+
+Demonstrates:
+- Subscribing to trade extra updates
+
+This example shows how to receive real-time market data for multiple symbols.
+"""
+
+import asyncio
+from datetime import datetime
+from trading_websocket import TradingClient
+import trading_websocket.models
+
+
+async def main():
+    # Initialize client
+    encoding = "msgpack"  # json or msgpack
+    client = TradingClient(
+        api_key="api-key",
+        api_secret="api-secret",
+        base_url="wss://ws-openapi.dnse.com.vn",
+        encoding=encoding,
+    )
+
+    def handle_trade_extra(trade: trading_websocket.models.TradeExtra):
+        received_at = datetime.fromtimestamp(trade.receivedAt).strftime("%H:%M:%S.%f")[:-3] if trade.receivedAt else "N/A"
+        print(f"[{received_at}] TRADE EXTRA: {trade}")
+
+    # Connect to gateway
+    print("Connecting to WebSocket gateway...")
+    await client.connect()
+    print(f"Connected! Session ID: {client._session_id}\n")
+
+    print("Subscribing to trade extra for SSI and 41I1G4000...")
+    await client.subscribe_trade_extra(["SSI", "41I1G4000"], on_trade_extra=handle_trade_extra, encoding=encoding, board_id="G1")
+
+    print("\nReceiving market data (will run for 1 hour)...\n")
+
+    # Run for 8H to collect data
+    # In a real application, you might run indefinitely or until a specific condition
+    await asyncio.sleep(8 * 60 * 60)
+
+    # Disconnect gracefully
+    print("\n\nDisconnecting...")
+    await client.disconnect()
+    print("Disconnected!")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

websocket-marketdata/trading_websocket/__init__.py

@@ -0,0 +1,33 @@
+"""Trading WebSocket SDK for Python.
+
+Async Python client for real-time trading data via WebSocket.
+"""
+
+from .client import TradingClient
+from .models import Trade, Quote, Ohlc, Order, Position, AccountUpdate
+from .exceptions import (
+    TradingWebSocketError,
+    ConnectionError,
+    ConnectionClosed,
+    AuthenticationError,
+    SubscriptionError,
+    EncodingError,
+)
+
+__version__ = "1.0.0"
+
+__all__ = [
+    "TradingClient",
+    "Trade",
+    "Quote",
+    "Ohlc",
+    "Order",
+    "Position",
+    "AccountUpdate",
+    "TradingWebSocketError",
+    "ConnectionError",
+    "ConnectionClosed",
+    "AuthenticationError",
+    "SubscriptionError",
+    "EncodingError",
+]

websocket-marketdata/trading_websocket/_version.py

@@ -0,0 +1,3 @@
+"""Version information for trading_websocket package."""
+
+__version__ = "1.0.0"

websocket-marketdata/trading_websocket/auth.py

@@ -0,0 +1,59 @@
+import hmac
+import hashlib
+import time
+from typing import Dict, Any
+
+
+class AuthManager:
+    """
+    HMAC-SHA256 authentication manager.
+
+    Handles signature generation and nonce creation for WebSocket authentication.
+    """
+
+    def __init__(self, api_key: str, api_secret: str):
+        """
+        Initialize auth manager.
+
+        Args:
+            api_key: API key
+            api_secret: API secret for HMAC signature
+        """
+        self.api_key = api_key
+        self.api_secret = api_secret
+
+    def create_auth_message(self) -> Dict[str, Any]:
+        timestamp = int(time.time())  # second
+        nonce = str(int(time.time() * 1000000))  # microseconds for uniqueness
+
+        signature = self.compute_signature(timestamp, nonce)
+
+        return {
+            "action": "auth",
+            "api_key": self.api_key,
+            "signature": signature,
+            "timestamp": timestamp,
+            "nonce": nonce
+        }
+
+    def compute_signature(self, timestamp: int, nonce: str) -> str:
+        """
+        Compute HMAC-SHA256 signature.
+
+        Args:
+            timestamp: Unix timestamp in second
+            nonce: Unique nonce string
+
+        Returns:
+            Hex-encoded HMAC signature
+        """
+        # Message format: {api_key}:{timestamp}:{nonce}
+        message = f"{self.api_key}:{timestamp}:{nonce}"
+
+        signature = hmac.new(
+            self.api_secret.encode('utf-8'),
+            message.encode('utf-8'),
+            hashlib.sha256
+        ).hexdigest()
+
+        return signature