p2bit 0.1.0__py3-none-any.whl

p2bit/__init__.py

@@ -0,0 +1,19 @@
+from .async_client import AsyncBybitClient
+from .client import SyncBybitClient
+from .exceptions import FailedRequestError
+from ._types import AccountType, Domain, Endpoint, Endpoints, HttpMethod, Tld
+
+VERSION = "0.0.1"
+
+__all__ = [
+    "AsyncBybitClient",
+    "SyncBybitClient",
+    "FailedRequestError",
+    "AccountType",
+    "Domain",
+    "Endpoint",
+    "Endpoints",
+    "HttpMethod",
+    "Tld",
+    "VERSION",
+]

p2bit/_api.py

@@ -0,0 +1,25 @@
+from typing import Any
+
+from _types import AccountType
+
+
+def build_balance_params(
+    *,
+    member_id: str | None = None,
+    account_type: AccountType = "FUND",
+    coins: list[str] | None = None,
+    with_bonus: bool = False,
+) -> dict[str, Any]:
+    if account_type == "UNIFIED" and not member_id:
+        raise ValueError("member_id is required for unified account type")
+
+    params: dict[str, Any] = {"accountType": account_type}
+
+    if member_id:
+        params["memberId"] = member_id
+    if coins:
+        params["coin"] = ",".join(coins)
+    if with_bonus:
+        params["withBonus"] = 1
+
+    return params

p2bit/_auth.py

@@ -0,0 +1,23 @@
+import base64
+import hashlib
+import hmac
+
+from Crypto.Hash import SHA256
+from Crypto.PublicKey import RSA
+from Crypto.Signature import PKCS1_v1_5
+
+
+def sign(
+    secret: str,
+    message: str | bytes,
+    *,
+    use_rsa: bool = False,
+) -> str:
+    data = message if isinstance(message, bytes) else message.encode("utf-8")
+
+    if use_rsa:
+        digest = SHA256.new(data)
+        signature = PKCS1_v1_5.new(RSA.import_key(secret)).sign(digest)
+        return base64.b64encode(signature).decode()
+
+    return hmac.new(secret.encode("utf-8"), data, hashlib.sha256).hexdigest()

p2bit/_base.py

@@ -0,0 +1,34 @@
+from _types import Domain, Tld
+
+
+def resolve_base_url(testnet: bool, domain: Domain, tld: Tld) -> str:
+    if testnet:
+        return "https://api-testnet.bybit.com"
+    return f"https://api.{domain}.{tld}"
+
+
+class BaseBybitClient:
+    def __init__(
+        self,
+        api_key: str,
+        api_secret: str,
+        *,
+        testnet: bool = False,
+        recv_window: int = 5000,
+        rsa: bool = False,
+        domain: Domain = "bybit",
+        tld: Tld = "com",
+        timeout: float = 10,
+    ) -> None:
+        if not api_key or not api_secret:
+            raise ValueError("api_key and api_secret are required")
+
+        self._api_key = api_key
+        self._api_secret = api_secret
+        self._testnet = testnet
+        self._recv_window = recv_window
+        self._rsa = rsa
+        self._domain = domain
+        self._tld = tld
+        self._timeout = timeout
+        self._base_url = resolve_base_url(testnet, domain, tld)

p2bit/_request.py

@@ -0,0 +1,158 @@
+import json
+import time
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from json import JSONDecodeError
+from typing import Any, Protocol
+
+from _auth import sign
+from _types import HttpMethod
+from exceptions import FailedRequestError
+
+
+class JsonResponse(Protocol):
+    status_code: int
+    headers: Any
+    text: str
+
+    def json(self) -> Any: ...
+
+
+@dataclass(frozen=True, slots=True)
+class PreparedRequest:
+    method: HttpMethod
+    path: str
+    headers: dict[str, str]
+    payload: str
+    endpoint: str
+
+
+def sanitize_params(params: dict[str, Any]) -> None:
+    for key, value in params.items():
+        if isinstance(value, float) and value.is_integer():
+            params[key] = int(value)
+
+
+def build_payload(method: HttpMethod, params: dict[str, Any]) -> str:
+    if method == "GET":
+        return "&".join(f"{key}={value}" for key, value in params.items())
+    return json.dumps(params)
+
+
+def build_signature(
+    api_key: str,
+    api_secret: str,
+    recv_window: int,
+    payload: str,
+    timestamp: int,
+    *,
+    use_rsa: bool = False,
+) -> str:
+    sign_string = f"{timestamp}{api_key}{recv_window}{payload}"
+    return sign(api_secret, sign_string, use_rsa=use_rsa)
+
+
+def build_headers(
+    api_key: str,
+    signature: str,
+    timestamp: int,
+    recv_window: int,
+) -> dict[str, str]:
+    return {
+        "X-BAPI-API-KEY": api_key,
+        "X-BAPI-SIGN": signature,
+        "X-BAPI-SIGN-TYPE": "2",
+        "X-BAPI-TIMESTAMP": str(timestamp),
+        "X-BAPI-RECV-WINDOW": str(recv_window),
+        "Content-Type": "application/json",
+    }
+
+
+def build_path(endpoint: str, method: HttpMethod, payload: str) -> str:
+    path = endpoint.lstrip("/")
+    if method == "GET" and payload:
+        return f"{path}?{payload}"
+    return path
+
+
+def build_full_url(base_url: str, path: str) -> str:
+    return f"{base_url}/{path}"
+
+
+def prepare_request(
+    api_key: str,
+    api_secret: str,
+    recv_window: int,
+    endpoint: str,
+    method: HttpMethod,
+    params: dict[str, Any] | None,
+    *,
+    use_rsa: bool = False,
+) -> PreparedRequest:
+    params = dict(params or {})
+    sanitize_params(params)
+
+    timestamp = int(time.time() * 1000)
+    payload = build_payload(method, params)
+    signature = build_signature(
+        api_key, api_secret, recv_window, payload, timestamp, use_rsa=use_rsa
+    )
+    headers = build_headers(api_key, signature, timestamp, recv_window)
+
+    return PreparedRequest(
+        method=method,
+        path=build_path(endpoint, method, payload),
+        headers=headers,
+        payload=payload,
+        endpoint=endpoint,
+    )
+
+
+def _failed_request(
+    response: JsonResponse,
+    endpoint: str,
+    payload: str,
+    message: str,
+    status_code: int | str,
+) -> FailedRequestError:
+    return FailedRequestError(
+        request=f"{endpoint}: {payload}",
+        message=message,
+        status_code=status_code,
+        time=datetime.now(timezone.utc).strftime("%H:%M:%S"),
+        resp_headers=response.headers,
+    )
+
+
+def process_response(response: JsonResponse, endpoint: str, payload: str) -> Any:
+    if response.status_code != 200:
+        if response.status_code == 403:
+            message = (
+                "Access denied error. Possible causes: 1) your IP is located "
+                "in the US or Mainland China, 2) IP banned due to ratelimit violation"
+            )
+        elif response.status_code == 401:
+            message = (
+                "Unauthorized. Possible causes: 1) incorrect API key and/or secret, "
+                "2) incorrect environment: Mainnet vs Testnet"
+            )
+        else:
+            message = f"HTTP status code is: {response.status_code}, expected: 200"
+        raise _failed_request(response, endpoint, payload, message, response.status_code)
+
+    try:
+        body = response.json()
+    except JSONDecodeError:
+        raise _failed_request(
+            response, endpoint, payload, "Could not decode JSON.", response.status_code
+        )
+
+    ret_code = "retCode" if "retCode" in body else "ret_code"
+    ret_msg = "retMsg" if "retMsg" in body else "ret_msg"
+
+    if body[ret_code]:
+        raise _failed_request(
+            response, endpoint, payload, body[ret_msg], body[ret_code]
+        )
+
+    return body

p2bit/_types.py

@@ -0,0 +1,21 @@
+from dataclasses import dataclass
+from typing import Literal
+
+HttpMethod = Literal["GET", "POST"]
+Domain = Literal["bybit", "bytick", "byhkbit"]
+Tld = Literal["com", "nl", "tr", "kz"]
+AccountType = Literal["UNIFIED", "FUND"]
+
+
+@dataclass(frozen=True, slots=True)
+class Endpoint:
+    path: str
+    method: HttpMethod
+
+
+class Endpoints:
+    ACCOUNT_INFO = Endpoint("/v5/p2p/user/personal/info", "POST")
+    CURRENT_BALANCE = Endpoint(
+        "/v5/asset/transfer/query-account-coins-balance", "GET"
+    )
+    RELEASE_ORDER = Endpoint("/v5/p2p/order/finish", "POST")

p2bit/async_client.py

@@ -0,0 +1,104 @@
+from typing import Any
+
+import httpx
+
+from _api import build_balance_params
+from _base import BaseBybitClient
+from _request import prepare_request, process_response
+from _types import AccountType, Domain, Endpoints, HttpMethod, Tld
+
+
+class AsyncBybitClient(BaseBybitClient):
+    def __init__(
+        self,
+        api_key: str,
+        api_secret: str,
+        *,
+        testnet: bool = False,
+        recv_window: int = 5000,
+        rsa: bool = False,
+        domain: Domain = "bybit",
+        tld: Tld = "com",
+        timeout: float = 10,
+    ) -> None:
+        super().__init__(
+            api_key,
+            api_secret,
+            testnet=testnet,
+            recv_window=recv_window,
+            rsa=rsa,
+            domain=domain,
+            tld=tld,
+            timeout=timeout,
+        )
+        self._http = httpx.AsyncClient(
+            base_url=self._base_url,
+            timeout=timeout,
+        )
+
+    async def __aenter__(self) -> "AsyncBybitClient":
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb) -> None:
+        await self.close()
+
+    async def close(self) -> None:
+        await self._http.aclose()
+
+    async def request(
+        self,
+        endpoint: str,
+        method: HttpMethod,
+        params: dict[str, Any] | None = None,
+    ) -> Any:
+        prepared = prepare_request(
+            self._api_key,
+            self._api_secret,
+            self._recv_window,
+            endpoint,
+            method,
+            params,
+            use_rsa=self._rsa,
+        )
+        request = self._http.build_request(
+            method=prepared.method,
+            url=prepared.path,
+            headers=prepared.headers,
+            content=prepared.payload if prepared.method == "POST" else None,
+        )
+        response = await self._http.send(request)
+        return process_response(response, prepared.endpoint, prepared.payload)
+
+    async def get_account_info(self) -> dict[str, Any]:
+        response = await self.request(
+            Endpoints.ACCOUNT_INFO.path,
+            Endpoints.ACCOUNT_INFO.method,
+        )
+        return response.get("result")
+
+    async def get_current_balance(
+        self,
+        member_id: str | None = None,
+        account_type: AccountType = "FUND",
+        coins: list[str] | None = None,
+        with_bonues: bool = False,
+    ) -> dict[str, Any]:
+        response = await self.request(
+            Endpoints.CURRENT_BALANCE.path,
+            Endpoints.CURRENT_BALANCE.method,
+            params=build_balance_params(
+                member_id=member_id,
+                account_type=account_type,
+                coins=coins,
+                with_bonus=with_bonues,
+            ),
+        )
+        return response.get("result")
+
+    async def release_order(self, order_id: str | int) -> dict[str, Any]:
+        response = await self.request(
+            Endpoints.RELEASE_ORDER.path,
+            Endpoints.RELEASE_ORDER.method,
+            params={"orderId": str(order_id)},
+        )
+        return response.get("result")

p2bit/client.py

@@ -0,0 +1,96 @@
+from typing import Any
+
+import requests
+
+from _api import build_balance_params
+from _base import BaseBybitClient
+from _request import build_full_url, prepare_request, process_response
+from _types import AccountType, Domain, Endpoints, HttpMethod, Tld
+
+
+class SyncBybitClient(BaseBybitClient):
+    def __init__(
+        self,
+        api_key: str,
+        api_secret: str,
+        *,
+        testnet: bool = False,
+        recv_window: int = 5000,
+        rsa: bool = False,
+        domain: Domain = "bybit",
+        tld: Tld = "com",
+        timeout: float = 10,
+    ) -> None:
+        super().__init__(
+            api_key,
+            api_secret,
+            testnet=testnet,
+            recv_window=recv_window,
+            rsa=rsa,
+            domain=domain,
+            tld=tld,
+            timeout=timeout,
+        )
+        self._http = requests.Session()
+
+    def request(
+        self,
+        endpoint: str,
+        method: HttpMethod,
+        params: dict[str, Any] | None = None,
+    ) -> Any:
+        prepared = prepare_request(
+            self._api_key,
+            self._api_secret,
+            self._recv_window,
+            endpoint,
+            method,
+            params,
+            use_rsa=self._rsa,
+        )
+        url = build_full_url(self._base_url, prepared.path)
+        request = requests.Request(
+            method=prepared.method,
+            url=url,
+            headers=prepared.headers,
+            data=prepared.payload if prepared.method == "POST" else None,
+        )
+        response = self._http.send(
+            self._http.prepare_request(request),
+            timeout=self._timeout,
+        )
+        return process_response(response, prepared.endpoint, prepared.payload)
+
+    def get_account_info(self) -> dict[str, Any]:
+        response = self.request(
+            Endpoints.ACCOUNT_INFO.path,
+            Endpoints.ACCOUNT_INFO.method,
+        )
+        return response.get("result")
+
+    def get_current_balance(
+        self,
+        member_id: str | None = None,
+        account_type: AccountType = "FUND",
+        coins: list[str] | None = None,
+        with_bonues: bool = False,
+    ) -> dict[str, Any]:
+        response = self.request(
+            Endpoints.CURRENT_BALANCE.path,
+            Endpoints.CURRENT_BALANCE.method,
+            params=build_balance_params(
+                member_id=member_id,
+                account_type=account_type,
+                coins=coins,
+                with_bonus=with_bonues,
+            ),
+        )
+        return response.get("result")
+
+    def release_order(self, order_id: str | int) -> dict[str, Any]:
+        response = self.request(
+            Endpoints.RELEASE_ORDER.path,
+            Endpoints.RELEASE_ORDER.method,
+            params={"orderId": str(order_id)},
+        )
+        return response.get("result")

p2bit/exceptions.py

@@ -0,0 +1,11 @@
+class FailedRequestError(Exception):
+    def __init__(self, request, message, status_code, time, resp_headers):
+        self.request = request
+        self.message = message
+        self.status_code = status_code
+        self.time = time
+        self.resp_headers = resp_headers
+        super().__init__(
+            f"{message.capitalize()} (ErrCode: {status_code}) (ErrTime: {time})"
+            f".\nRequest → {request}."
+        )

p2bit-0.1.0.dist-info/METADATA

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: p2bit
+Version: 0.1.0
+Summary: Sync/async lib for the Bybit API
+Author-email: herbalsommml <herbalsomml@gmail.com>
+Requires-Python: >=3.11
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: pycryptodome>=3.23.0
+Requires-Dist: requests>=2.34.2

p2bit-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+p2bit/__init__.py,sha256=VBIKpp1KzRKxmWDFY-5xDiV5gRIb1W3XDj3uF1AQaxo,417
+p2bit/_api.py,sha256=VVc5sDiwFtcp6mBZcWJIyauCgN6qfoSSV8uaUxV0KWo,621
+p2bit/_auth.py,sha256=0kmt-bb85kucS0OkiJoMM8RfL-JBGhSvnFLE_drttiM,577
+p2bit/_base.py,sha256=rwGl9qylpL_254jy4Yb5qI7eBbYpaLAiCu6xnKj-KGg,944
+p2bit/_request.py,sha256=vvaWZ57O6SO7NYVZKwgcaXrT0MLmCKrDhp5P39aINBA,4264
+p2bit/_types.py,sha256=VV46auNr4yRfw2pe1dVN7isVmgMxVEzuqSvzXRN0m6o,564
+p2bit/async_client.py,sha256=o6DAjKMFnx8VFidTeK4uyBYwulph3oocNvDQmx6_QKw,3030
+p2bit/client.py,sha256=tGIo7EBMTXZd-L3VdxUq4lSR3Q_U1KBMekPRAYyW7ZA,2818
+p2bit/exceptions.py,sha256=3lOo0QDmfJRlSo3-HJYm3d4gawJGxkd9uFtGTnhwg9A,436
+p2bit-0.1.0.dist-info/METADATA,sha256=cSx8PW-yfHRo-LZiVzdnQL7ShujVUzJRhhMhpEeMx8M,263
+p2bit-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+p2bit-0.1.0.dist-info/top_level.txt,sha256=GR7803Hre1eOJxzXMD8LEWUQ8XbFZoJ_dCvc0Nas7VE,6
+p2bit-0.1.0.dist-info/RECORD,,

p2bit-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

p2bit-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+p2bit