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

broker-api/get_list_care_by.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.get_list_care_by(dry_run=False)
+    print(status, body)
+
+
+if __name__ == "__main__":
+    main()

dnse/__init__.py

@@ -0,0 +1,4 @@
+#!/usr/bin/env python3
+from .client import DNSEClient
+
+__all__ = ["DNSEClient"]

dnse/client.py

@@ -0,0 +1,408 @@
+#!/usr/bin/env python3
+import json
+import os
+from urllib import parse
+import urllib3
+
+
+from .common import build_signature, get_date_header_name
+
+
+class DNSEClient:
+    def __init__(
+            self,
+            api_key,
+            api_secret,
+            base_url="https://openapi.dnse.com.vn",
+            algorithm="hmac-sha256",
+            hmac_nonce_enabled=True,
+    ):
+        self._api_key = api_key
+        self._api_secret = api_secret
+        self._base_url = base_url.rstrip("/")
+        self._algorithm = algorithm
+        self._hmac_nonce_enabled = hmac_nonce_enabled
+
+        # Tạo PoolManager 1 lần duy nhất, tái sử dụng suốt vòng đời object
+        self._http = urllib3.PoolManager(
+            num_pools=10,           # Số lượng connection pools
+            maxsize=10,             # Số connections tối đa mỗi pool
+            block=False,            # Không block khi pool đầy
+            timeout=urllib3.Timeout(connect=30.0, read=60.0),
+            # cert_reqs = 'CERT_NONE',  # Không yêu cầu certificate
+            # assert_hostname = False  # Không kiểm tra hostname
+        )
+
+    def get_accounts(self, dry_run=False):
+        return self._request("GET", "/accounts", dry_run=dry_run)
+
+    def get_balances(self, account_no, dry_run=False):
+        return self._request("GET", f"/accounts/{account_no}/balances", dry_run=dry_run)
+
+    def get_loan_packages(self, account_no, market_type, symbol=None, dry_run=False):
+        query = {"marketType": market_type}
+        if symbol:
+            query["symbol"] = symbol
+        return self._request(
+            "GET",
+            f"/accounts/{account_no}/loan-packages",
+            query=query,
+            dry_run=dry_run,
+        )
+
+    def get_positions(self, account_no, market_type, dry_run=False):
+        return self._request(
+            "GET",
+            f"/accounts/{account_no}/positions",
+            query={"marketType": market_type},
+            dry_run=dry_run,
+        )
+
+    def get_position_by_id(self, market_type, position_id, dry_run=False):
+        return self._request(
+            "GET",
+            f"/accounts/positions/{position_id}",
+            query={"marketType": market_type},
+            dry_run=dry_run,
+        )
+
+    def get_orders(self, account_no, market_type, order_category=None, dry_run=False):
+        query = {"marketType": market_type}
+        if order_category:
+            query["orderCategory"] = order_category
+        return self._request(
+            "GET",
+            f"/accounts/{account_no}/orders",
+            query=query,
+            dry_run=dry_run,
+        )
+
+    def get_order_detail(self, account_no, order_id, market_type, order_category=None, dry_run=False):
+        query = {"marketType": market_type}
+        if order_category:
+            query["orderCategory"] = order_category
+        return self._request(
+            "GET",
+            f"/accounts/{account_no}/orders/{order_id}",
+            query=query,
+            dry_run=dry_run,
+        )
+
+    def get_execution_detail(self, account_no, order_id, market_type, order_category="NORMAL", dry_run=False):
+        query = {"marketType": market_type}
+        if order_category:
+            query["orderCategory"] = order_category
+        return self._request(
+            "GET",
+            f"/accounts/{account_no}/executions/{order_id}",
+            query=query,
+            dry_run=dry_run,
+        )
+
+    def get_order_history(
+            self,
+            account_no,
+            market_type,
+            from_date=None,
+            to_date=None,
+            page_size=None,
+            page_index=None,
+            dry_run=False,
+    ):
+        query = {"marketType": market_type}
+        if from_date:
+            query["from"] = from_date
+        if to_date:
+            query["to"] = to_date
+        if page_size is not None:
+            query["pageSize"] = page_size
+        if page_index is not None:
+            query["pageIndex"] = page_index
+        return self._request(
+            "GET",
+            f"/accounts/{account_no}/orders/history",
+            query=query,
+            dry_run=dry_run,
+        )
+
+    def get_ppse(self, account_no, market_type, symbol, price, loan_package_id, dry_run=False):
+        return self._request(
+            "GET",
+            f"/accounts/{account_no}/ppse",
+            query={
+                "marketType": market_type,
+                "symbol": symbol,
+                "price": str(price),
+                "loanPackageId": str(loan_package_id),
+            },
+            dry_run=dry_run,
+        )
+
+    def get_security_definition(self, symbol, board_id=None, dry_run=False):
+        query = {}
+        if board_id:
+            query["boardId"] = board_id
+        return self._request(
+            "GET",
+            f"/price/{symbol}/secdef",
+            query=query if query else None,
+            dry_run=dry_run,
+        )
+
+    def get_ohlc(self, bar_type, query=None, dry_run=False):
+        request_query = dict(query or {})
+        request_query["type"] = bar_type
+        return self._request(
+            "GET",
+            "/price/ohlc",
+            query=request_query,
+            dry_run=dry_run,
+        )
+
+    def get_trades(self, symbol, board_id=None, from_date=None, to_date=None, limit=None, order = None, next_page_token=None, dry_run=False):
+        query = {}
+        if board_id is not None:
+            query["boardId"] = board_id
+        if from_date is not None:
+            query["from"] = from_date
+        if to_date is not None:
+            query["to"] = to_date
+        if limit is not None:
+            query["limit"] = limit
+        if order is not None:
+            query["order"] = order
+        if next_page_token is not None:
+            query["nextPageToken"] = next_page_token
+        return self._request(
+            "GET",
+            f"/price/{symbol}/trades",
+            query=query if query else None,
+            dry_run=dry_run,
+        )
+
+    def get_instruments(self, symbol=None, market_id=None, security_group_id=None, index_name=None, limit=None, page=None, dry_run=False):
+        query = {}
+        if symbol is not None:
+            query["symbol"] = symbol
+        if market_id is not None:
+            query["marketId"] = market_id
+        if security_group_id is not None:
+            query["securityGroupId"] = security_group_id
+        if index_name is not None:
+            query["indexName"] = index_name
+        if limit is not None:
+            query["limit"] = limit
+        if page is not None:
+            query["page"] = page
+        return self._request(
+            "GET",
+            f"/instruments",
+            query=query if query else None,
+            dry_run=dry_run,
+        )
+
+    def get_latest_trade(self, symbol, board_id=None, dry_run=False):
+        query = {}
+        if board_id is not None:
+            query["boardId"] = board_id
+        return self._request(
+            "GET",
+            f"/price/{symbol}/trades/latest",
+            query=query if query else None,
+            dry_run=dry_run,
+        )
+
+    def get_close_price(self, symbol, board_id=None, dry_run=False):
+        query = {}
+        if board_id is not None:
+            query["boardId"] = board_id
+        return self._request(
+            "GET",
+            f"/price/{symbol}/close",
+            query=query if query else None,
+            dry_run=dry_run,
+        )
+
+    def get_working_dates(self, dry_run=False):
+        return self._request(
+            "GET",
+            f"/market/working-dates",
+            dry_run=dry_run,
+        )
+
+    def get_list_care_by(self, dry_run=False):
+        return self._request(
+            "GET",
+            f"/brokers/accounts/care-by",
+            dry_run=dry_run,
+        )
+
+    def post_order(self, market_type, payload, trading_token, order_category="NORMAL", dry_run=False):
+        headers = {"trading-token": trading_token}
+        query = {"marketType": market_type}
+        if order_category:
+            query["orderCategory"] = order_category
+        return self._request(
+            "POST",
+            "/accounts/orders",
+            query=query,
+            body=payload,
+            headers=headers,
+            dry_run=dry_run,
+        )
+
+    def put_order(
+        self,
+        account_no,
+        order_id,
+        market_type,
+        payload,
+        trading_token,
+        order_category=None,
+        dry_run=False,
+    ):
+        headers = {"trading-token": trading_token}
+        query = {"marketType": market_type}
+        if order_category:
+            query["orderCategory"] = order_category
+        return self._request(
+            "PUT",
+            f"/accounts/{account_no}/orders/{order_id}",
+            query=query,
+            body=payload,
+            headers=headers,
+            dry_run=dry_run,
+        )
+
+    def cancel_order(
+        self,
+        account_no,
+        order_id,
+        market_type,
+        trading_token,
+        order_category=None,
+        dry_run=False,
+    ):
+        headers = {"trading-token": trading_token}
+        query = {"marketType": market_type}
+        if order_category:
+            query["orderCategory"] = order_category
+        return self._request(
+            "DELETE",
+            f"/accounts/{account_no}/orders/{order_id}",
+            query=query,
+            headers=headers,
+            dry_run=dry_run,
+        )
+
+    def create_trading_token(self, otp_type, passcode, dry_run=False):
+        return self._request(
+            "POST",
+            "/registration/trading-token",
+            body={"otpType": otp_type, "passcode": passcode},
+            dry_run=dry_run,
+        )
+
+    def send_email_otp(self, dry_run=False):
+        return self._request(
+            "POST",
+            "/registration/send-email-otp",
+            dry_run=dry_run,
+        )
+
+    def close_position(self, position_id, market_type, trading_token, dry_run=False):
+        headers = {"trading-token": trading_token}
+        query = {"marketType": market_type}
+        return self._request(
+            "POST",
+            f"/accounts/positions/{position_id}/close",
+            query=query,
+            headers=headers,
+            dry_run=dry_run,
+        )
+
+    def _request(self, method, path, query=None, body=None, headers=None, dry_run=False):
+        debug = os.getenv("DEBUG", "").lower() == "true"
+        url = self._build_url(path, query)
+        date_value, signature_header_value = self._signature_headers(method, path)
+        date_header_name = get_date_header_name()
+
+        # Build headers dict
+        req_headers = {
+            date_header_name: date_value,
+            "X-Signature": signature_header_value,
+            "x-api-key": self._api_key,
+        }
+
+        if body is not None:
+            req_headers["Content-Type"] = "application/json"
+
+        if headers:
+            req_headers.update(headers)
+
+        # Prepare body data
+        data = None
+        if body is not None:
+            data = json.dumps(body)
+
+        if debug or dry_run:
+            prefix = "DRY RUN" if dry_run else "DEBUG"
+            print(f"{prefix} url:", url)
+            print(f"{prefix} method:", method)
+            print(f"{prefix} query_params:", query or {})
+            print(f"{prefix} headers:", req_headers)
+            print(f"{prefix} body:", body)
+
+        if dry_run:
+            return None, None
+
+        try:
+            resp = self._http.request(
+                method,
+                url,
+                body=data,
+                headers=req_headers,
+            )
+            body_text = resp.data.decode("utf-8")
+            return resp.status, body_text
+        except urllib3.exceptions.HTTPError as err:
+            if hasattr(err, 'response') and err.response:
+                body_text = err.response.data.decode("utf-8") if err.response.data else ""
+                return err.response.status, body_text
+            raise
+
+    def _build_url(self, path, query):
+        url = f"{self._base_url}{path}"
+        if query:
+            url = f"{url}?{parse.urlencode(query)}"
+        return url
+
+    def _signature_headers(self, method, path):
+        date_value = self._date_header()
+        nonce = None
+        if self._hmac_nonce_enabled:
+            import uuid
+
+            nonce = uuid.uuid4().hex
+
+        headers_list, signature = build_signature(
+            self._api_secret,
+            method,
+            path,
+            date_value,
+            self._algorithm,
+            nonce=nonce,
+            header_name=get_date_header_name(),
+        )
+        signature_header_value = (
+            f'Signature keyId="{self._api_key}",algorithm="{self._algorithm}",'
+            f'headers="{headers_list}",signature="{signature}"'
+        )
+        if nonce:
+            signature_header_value += f',nonce="{nonce}"'
+        return date_value, signature_header_value
+
+    def _date_header(self):
+        from datetime import datetime, timezone
+
+        return datetime.now(timezone.utc).strftime("%a, %d %b %Y %H:%M:%S %z")

dnse/common.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+import base64
+import hashlib
+import hmac
+import json
+import os
+from datetime import datetime, timezone
+from urllib import parse, request
+from uuid import uuid4
+
+
+def get_date_header_name():
+    return os.getenv("DATE_HEADER", "Date")
+
+
+def build_signature(secret, method, path, date_value, algorithm, nonce=None, header_name=None):
+    header_name = header_name or get_date_header_name()
+    header_key = header_name.lower()
+    headers = f"(request-target) {header_key}"
+    signature_string = (
+        f"(request-target): {method.lower()} {path}\n" f"{header_key}: {date_value}"
+    )
+    if nonce:
+        signature_string += f"\nnonce: {nonce}"
+
+    if algorithm == "hmac-sha256":
+        digestmod = hashlib.sha256
+    elif algorithm == "hmac-sha384":
+        digestmod = hashlib.sha384
+    elif algorithm == "hmac-sha512":
+        digestmod = hashlib.sha512
+    else:
+        digestmod = hashlib.sha1
+
+    mac = hmac.new(secret.encode("utf-8"), signature_string.encode("utf-8"), digestmod)
+    encoded = base64.b64encode(mac.digest()).decode("utf-8")
+    escaped = parse.quote(encoded, safe="")
+
+    return headers, escaped
+
+
+def send_signed_request(
+    url,
+    method,
+    headers,
+    body,
+    api_key,
+    api_secret,
+    algorithm="hmac-sha256",
+    hmac_nonce_enabled=True,
+):
+    debug = os.getenv("DEBUG", "").lower() == "true"
+    parsed = parse.urlparse(url)
+    path = parsed.path
+    date_value = datetime.now(timezone.utc).strftime("%a, %d %b %Y %H:%M:%S %z")
+    date_header_name = get_date_header_name()
+
+    nonce = uuid4().hex if hmac_nonce_enabled else None
+    headers_list, signature = build_signature(
+        api_secret,
+        method,
+        path,
+        date_value,
+        algorithm,
+        nonce=nonce,
+        header_name=date_header_name,
+    )
+    signature_header_value = (
+        f'Signature keyId="{api_key}",algorithm="{algorithm}",'
+        f'headers="{headers_list}",signature="{signature}"'
+    )
+    if nonce:
+        signature_header_value += f',nonce="{nonce}"'
+
+    data = None
+    if body is not None:
+        data = json.dumps(body).encode("utf-8")
+        headers.setdefault("Content-Type", "application/json")
+
+    req = request.Request(url, data=data, method=method)
+    req.add_header(date_header_name, date_value)
+    req.add_header("X-Signature", signature_header_value)
+
+    for key, value in headers.items():
+        req.add_header(key, value)
+
+    if debug:
+        query_params = parse.parse_qs(parsed.query)
+        print("DEBUG url:", url)
+        print("DEBUG method:", method)
+        print("DEBUG query_params:", query_params)
+        print("DEBUG headers:", dict(req.header_items()))
+        print("DEBUG body:", body)
+
+    try:
+        with request.urlopen(req) as resp:
+            body_text = resp.read().decode("utf-8")
+            print(body_text)
+    except request.HTTPError as err:
+        body_text = err.read().decode("utf-8") if err.fp else ""
+        print(f"HTTP {err.code} {err.reason}")
+        if body_text:
+            print(body_text)

dnse_sdk_openapi-0.0.1.dist-info/METADATA

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: dnse-sdk-openapi
+Version: 0.0.1
+Summary: DNSE OpenAPI SDK
+Description-Content-Type: text/markdown
+
+# DNSE OpenAPI Python SDK
+
+Official Python SDK for integrating with DNSE OpenAPI.
+
+## Table of Contents
+
+- [Overview](#overview)
+- [Installation](#installation)
+- [Usage](#usage)
+- [Dry Run](#dry-run)
+- [Examples](#examples)
+
+### Overview
+
+DNSE OpenAPI is an API-first trading platform that enables developers to integrate brokerage, trading, margin, and market data services
+into their own applications.
+
+The DNSE Python SDK provides a lightweight client for securely interacting with DNSE OpenAPI REST endpoints. It handles request
+signing, authentication, and communication details, allowing developers to focus on building trading systems, automation strategies,
+and investment applications.
+
+### Installation
+
+#### Requirements
+
+- Python 3.8+
+
+#### Install from PyPI
+
+```console
+pip install openapi-sdk 
+```
+
+Upgrade
+
+### Usage
+
+Create a `DNSEClient` instance with your API credentials:
+
+```python
+from dnse import DNSEClient
+
+client = DNSEClient(
+    api_key="your_api_key",
+    api_secret="your_api_secret",
+    base_url="https://openapi.dnse.com.vn",
+)
+
+status, body = client.get_accounts(dry_run=False)
+print(status, body)
+```
+
+### Dry Run
+
+Set `dry_run=True` to preview the request without sending it to DNSE servers. No network call will be executed.
+
+```python
+client.get_accounts(dry_run=True)
+```
+
+### Examples
+
+Run any example from the `sdk/python/examples` directory:
+
+```
+python sdk/python/api/get_accounts.py
+```
+
+#### Trading API
+
+| Function                  | Description                                                                                                           |
+|---------------------------|-----------------------------------------------------------------------------------------------------------------------|
+| `get_accounts.py`         | Demonstrates how to retrieve all trading sub-accounts managed under the account corresponding to the API Key.         |
+| `get_balances.py`         | Demonstrates how to retrieve asset balances of a trading sub-account.                                                 |
+| `get_loan_packages.py`    | Demonstrates how to retrieve available loan package codes. It is necessary for placing an order.                      |
+| `get_ppse.py`             | Demonstrates how to retrieve buying power and selling power before placing an order.                                  |
+| `get_orders.py`           | Demonstrates how to retrieve intraday order book.                                                                     |
+| `get_order_detail.py`     | Demonstrates how to retrieve detailed information of a specific order (by ID).                                        |
+| `get_order_history.py`    | Demonstrates how to retrieve historical orders.                                                                       |
+| `get_execution_detail.py` | Demonstrates how to retrieve detailed execution information of an order.                                              |
+| `get_positions.py`        | Demonstrates how to retrieve current holding positions.                                                               |
+| `get_positions_by_id.py`  | Demonstrates how to retrieve detailed information of a specific position (by ID).                                     |
+| `close_position.py`       | Demonstrates how to close an existing position (by ID).                                                               |
+| `send_email_otp.py`       | Demonstrates how to request an OTP sent to your registered email. The OTP is required for generating a trading token. |
+| `create_trading_token.py` | Demonstrates how to generate a Trading Token required for order placement.                                            |
+| `post_order.py`           | Demonstrates how to submit a new trading order.                                                                       |
+| `cancel_order.py`         | Demonstrates how to cancel an existing order.                                                                         |
+| `replace_order.py`        | Demonstrates how to modify an existing order.                                                                         |
+
+#### Market Data API
+
+| Function                     | Description                                                                                |
+|------------------------------|--------------------------------------------------------------------------------------------|
+| `get_security_definition.py` | Demonstrates how to retrieve security definition and instrument details.                   |
+| `get_instruments.py`         | Demonstrates how to retrieve the list of available trading instruments and their metadata. |
+| `get_trades.py`              | Demonstrates how to retrieve historical trade data for a specific instrument.              |
+| `get_latest_trade.py`        | Demonstrates how to retrieve the most recent trade for a specific instrument.              |
+| `get_ohlc.py`                | Demonstrates how to retrieve OHLC (Open, High, Low, Close) data for a given time range.    |
+| `get_close_price.py`         | Demonstrates how to retrieve the latest closing price of a specific instrument.            |
+| `get_working_dates.py`       | Demonstrates how to retrieve trading working dates.                                        |
+
+### WebSocket Market Data
+
+| Function              | Description                                                                          |
+|-----------------------|--------------------------------------------------------------------------------------|
+| `sec_def.py`          | Demonstrates how to receive real-time security definition updates.                   |
+| `quote.py`            | Demonstrates how to receive real-time best bid and ask prices.                       |
+| `trade.py`            | Demonstrates how to receive real-time trade (tick) data.                             |
+| `trade_extra.py`      | Demonstrates how to receive real-time trade data with additional aggregated metrics. |
+| `ohlc.py`             | Demonstrates how to receive real-time OHLC data.                                     |
+| `ohlc_closed.py`      | Demonstrates how to receive completed OHLC candle data.                              |
+| `expected_price.py`   | Demonstrates how to receive expected price data during ATO and ATC sessions.         |
+| `foreign_investor.py` | Demonstrates how to receive foreign investor trading data.                           |
+| `market_index.py`     | Demonstrates how to receive market index data.                                       |