dnse-sdk 0.1.0__tar.gz

dnse_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: dnse-sdk
+Version: 0.1.0
+Summary: DNSE Python SDK
+Author: DNSE
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# DNSE Python SDK
+
+This SDK provides a simple client for calling the DNSE APIs with HMAC signatures.
+
+## Requirements
+
+- Python 3.8+
+
+## Usage
+
+```python
+from dnse import DNSEClient
+
+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_accounts(dry_run=False)
+print(status, body)
+```
+
+## Dry run
+
+Set `dry_run=True` on any API call to print the request and skip the network call.
+
+## Examples
+
+Run any example from the `sdk/python/trading-api` directory:
+
+```bash
+python sdk/python/trading-api/get_accounts.py
+```
+
+Available examples:
+
+- cancel_order.py
+- create_trading_token.py
+- get_accounts.py
+- get_balances.py
+- get_deals.py
+- get_loan_packages.py
+- get_ohlc.py
+- get_order_detail.py
+- get_order_history.py
+- get_orders.py
+- get_ppse.py
+- get_security_definition.py
+- post_order.py
+- put_order.py
+- send_email_otp.py

dnse_sdk-0.1.0/README.md

@@ -0,0 +1,52 @@
+# DNSE Python SDK
+
+This SDK provides a simple client for calling the DNSE APIs with HMAC signatures.
+
+## Requirements
+
+- Python 3.8+
+
+## Usage
+
+```python
+from dnse import DNSEClient
+
+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_accounts(dry_run=False)
+print(status, body)
+```
+
+## Dry run
+
+Set `dry_run=True` on any API call to print the request and skip the network call.
+
+## Examples
+
+Run any example from the `sdk/python/trading-api` directory:
+
+```bash
+python sdk/python/trading-api/get_accounts.py
+```
+
+Available examples:
+
+- cancel_order.py
+- create_trading_token.py
+- get_accounts.py
+- get_balances.py
+- get_deals.py
+- get_loan_packages.py
+- get_ohlc.py
+- get_order_detail.py
+- get_order_history.py
+- get_orders.py
+- get_ppse.py
+- get_security_definition.py
+- post_order.py
+- put_order.py
+- send_email_otp.py

dnse_sdk-0.1.0/dnse/__init__.py

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

dnse_sdk-0.1.0/dnse/client.py

@@ -0,0 +1,291 @@
+#!/usr/bin/env python3
+import json
+import os
+from urllib import parse, request
+
+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
+
+    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_deals(self, account_no, market_type, dry_run=False):
+        return self._request(
+            "GET",
+            f"/accounts/{account_no}/deals",
+            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_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/secdef/{symbol}",
+            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 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_deal(self, deal_id, account_no, market_type, payload, trading_token, dry_run=False):
+        headers = {"trading-token": trading_token}
+        query = {"marketType": market_type}
+        return self._request(
+            "POST",
+            f"/accounts/{account_no}/deals/{deal_id}/close",
+            query=query,
+            body=payload,
+            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()
+
+        data = None
+        if body is not None:
+            data = json.dumps(body).encode("utf-8")
+
+        req = request.Request(url, data=data, method=method)
+        req.add_header(date_header_name, date_value)
+        req.add_header("X-Signature", signature_header_value)
+        req.add_header("x-api-key", self._api_key)
+
+        if body is not None:
+            req.add_header("Content-Type", "application/json")
+
+        if headers:
+            for key, value in headers.items():
+                req.add_header(key, value)
+
+        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:", dict(req.header_items()))
+            print(f"{prefix} body:", body)
+
+        if dry_run:
+            return None, None
+
+        try:
+            with request.urlopen(req) as resp:
+                body_text = resp.read().decode("utf-8")
+                return resp.status, body_text
+        except request.HTTPError as err:
+            body_text = err.read().decode("utf-8") if err.fp else ""
+            return err.code, body_text
+
+    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_sdk-0.1.0/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-0.1.0/dnse_sdk.egg-info/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: dnse-sdk
+Version: 0.1.0
+Summary: DNSE Python SDK
+Author: DNSE
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# DNSE Python SDK
+
+This SDK provides a simple client for calling the DNSE APIs with HMAC signatures.
+
+## Requirements
+
+- Python 3.8+
+
+## Usage
+
+```python
+from dnse import DNSEClient
+
+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_accounts(dry_run=False)
+print(status, body)
+```
+
+## Dry run
+
+Set `dry_run=True` on any API call to print the request and skip the network call.
+
+## Examples
+
+Run any example from the `sdk/python/trading-api` directory:
+
+```bash
+python sdk/python/trading-api/get_accounts.py
+```
+
+Available examples:
+
+- cancel_order.py
+- create_trading_token.py
+- get_accounts.py
+- get_balances.py
+- get_deals.py
+- get_loan_packages.py
+- get_ohlc.py
+- get_order_detail.py
+- get_order_history.py
+- get_orders.py
+- get_ppse.py
+- get_security_definition.py
+- post_order.py
+- put_order.py
+- send_email_otp.py

dnse_sdk-0.1.0/dnse_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+setup.cfg
+setup.py
+dnse/__init__.py
+dnse/client.py
+dnse/common.py
+dnse_sdk.egg-info/PKG-INFO
+dnse_sdk.egg-info/SOURCES.txt
+dnse_sdk.egg-info/dependency_links.txt
+dnse_sdk.egg-info/top_level.txt

dnse_sdk-0.1.0/dnse_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

dnse_sdk-0.1.0/dnse_sdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+dnse

dnse_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"

dnse_sdk-0.1.0/setup.cfg

@@ -0,0 +1,22 @@
+[metadata]
+name = dnse-sdk
+version = 0.1.0
+description = DNSE Python SDK
+long_description = file: README.md
+long_description_content_type = text/markdown
+author = DNSE
+
+[options]
+packages = find:
+python_requires = >=3.8
+include_package_data = True
+
+[options.packages.find]
+include = 
+	dnse
+	dnse.*
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

dnse_sdk-0.1.0/setup.py

@@ -0,0 +1,4 @@
+from setuptools import setup
+
+
+setup()