trd-utils 0.0.57__py3-none-any.whl

trd_utils/exchanges/hyperliquid/hyperliquid_types.py

@@ -0,0 +1,183 @@
+from decimal import Decimal
+from trd_utils.types_helper import BaseModel, new_list
+
+
+###########################################################
+
+
+# region Common types
+
+
+class HyperLiquidApiResponse(BaseModel):
+    time: int = None
+
+
+# endregion
+
+###########################################################
+
+
+# region info types
+
+
+class CumFundingInfo(BaseModel):
+    all_time: str = None
+    since_open: str = None
+    since_change: str = None
+
+
+class LeverageInfo(BaseModel):
+    type: str = None
+    value: int = None
+
+
+class PositionInfo(BaseModel):
+    coin: str = None
+    szi: Decimal = None
+    leverage: LeverageInfo = None
+    entry_px: Decimal = None
+    position_value: Decimal = None
+    unrealized_pnl: Decimal = None
+    return_on_equity: Decimal = None
+    liquidation_px: Decimal = None
+    margin_used: Decimal = None
+    max_leverage: int = None
+    cum_funding: CumFundingInfo = None
+
+    def get_side(self) -> str:
+        if self.szi > 0:
+            return "LONG"
+        elif self.szi < 0:
+            return "SHORT"
+        return "UNKNOWN_SIDE"
+
+    def get_position_id(self) -> str:
+        """
+        As far as I know, the API endpoint does not return the position id,
+        maybe it only returns it to the account owner?
+        In any case, we will have to somehow fake it in order to be able to compare
+        it with other positions...
+        """
+        return (
+            (f"{self.coin}-{self.leverage.value}-{1 if self.szi > 0 else 0}")
+            .encode("utf-8")
+            .hex()
+        )
+
+    def get_leverage(self) -> str:
+        return f"{self.leverage.value}x ({self.leverage.type})"
+
+    def __repr__(self):
+        return (
+            f"{self.get_side()} {self.get_leverage()} {self.coin} "
+            f"Margin: {self.margin_used}, PNL: {self.unrealized_pnl}"
+        )
+
+    def __str__(self):
+        return self.__repr__()
+
+
+class AssetPosition(BaseModel):
+    type: str = None
+    position: PositionInfo = None
+
+    def __repr__(self):
+        return f"{self.position}; {self.type}"
+
+    def __str__(self):
+        return self.__str__()
+
+    def get_position_id(self) -> str:
+        return self.position.get_position_id()
+
+
+class MarginSummaryInfo(BaseModel):
+    account_value: Decimal = None
+    total_ntl_pos: Decimal = None
+    total_raw_usd: Decimal = None
+    total_margin_used: Decimal = None
+
+
+class TraderPositionsInfoResponse(BaseModel):
+    margin_summary: MarginSummaryInfo = None
+    cross_margin_summary: MarginSummaryInfo = None
+    cross_maintenance_margin_used: Decimal = None
+    withdrawable: Decimal = None
+    asset_positions: list[AssetPosition] = None
+
+
+class MetaAssetCtxSingleInfo(BaseModel):
+    symbol: str = None
+    mark_px: Decimal = None
+    prev_day_px: Decimal = None
+    change_abs: Decimal = None
+    change_pct: Decimal = None
+    funding: Decimal = None
+    day_ntl_vlm: Decimal = None
+    open_interest: Decimal = None
+
+
+class MetaAssetCtxResponse(BaseModel):
+    assets: list[MetaAssetCtxSingleInfo] = None
+
+    @staticmethod
+    def parse_from_api_resp(
+        data: dict,
+        allow_delisted: bool = False,
+    ) -> "MetaAssetCtxResponse":
+        resp = MetaAssetCtxResponse()
+        resp.assets = new_list()
+        meta, asset_ctxs = data
+        if not isinstance(meta, dict) or not isinstance(asset_ctxs, list):
+            raise ValueError("Unexpected response structure from metaAndAssetCtxs")
+
+        universe = meta.get("universe", [])
+
+        for meta_entry, ctx in zip(universe, asset_ctxs, strict=False):
+            if not isinstance(meta_entry, dict) or not isinstance(ctx, dict):
+                continue
+
+            name = meta_entry["name"]  # e.g. "BTC", "ETH", "SOL", ...
+            if not allow_delisted and meta_entry.get("isDelisted", False):
+                continue
+
+            # Convert interesting fields to floats
+            mark_px = float(ctx["markPx"])
+            prev_day_px_str = ctx.get("prevDayPx")  # may be missing for some markets
+            prev_day_px = (
+                float(prev_day_px_str)
+                if prev_day_px_str not in (None, "", "0")
+                else None
+            )
+
+            funding = float(ctx["funding"])
+            day_ntl_vlm = float(ctx["dayNtlVlm"])
+            open_interest = float(ctx["openInterest"])
+
+            if prev_day_px and prev_day_px != 0.0:
+                change_abs = mark_px - prev_day_px
+                change_pct = (change_abs / prev_day_px) * 100.0
+            else:
+                change_abs = None
+                change_pct = None
+
+            resp.assets.append(
+                MetaAssetCtxSingleInfo(
+                    **{
+                        "symbol": name,
+                        "mark_px": mark_px,
+                        "prev_day_px": prev_day_px,
+                        "change_abs": change_abs,
+                        "change_pct": change_pct,
+                        "funding": funding,
+                        "day_ntl_vlm": day_ntl_vlm,
+                        "open_interest": open_interest,
+                    },
+                )
+            )
+        return resp
+
+
+# endregion
+
+###########################################################

trd_utils/exchanges/okx/__init__.py

@@ -0,0 +1,6 @@
+from .okx_client import OkxClient
+
+
+__all__ = [
+    "OkxClient",
+]

trd_utils/exchanges/okx/okx_client.py

@@ -0,0 +1,219 @@
+from decimal import Decimal
+import json
+import logging
+import time
+import httpx
+
+from pathlib import Path
+
+from trd_utils.cipher import AESCipher
+from trd_utils.exchanges.base_types import (
+    UnifiedPositionInfo,
+    UnifiedTraderInfo,
+    UnifiedTraderPositions,
+)
+from trd_utils.exchanges.exchange_base import ExchangeBase
+from trd_utils.exchanges.okx.okx_types import (
+    AppContextUserInfo,
+    CurrentUserPositionsResponse,
+    UserInfoHtmlParser,
+    UserInfoInitialProps,
+)
+from trd_utils.types_helper import new_list
+
+logger = logging.getLogger(__name__)
+
+BASE_PROFILE_URL = "https://www.okx.com/copy-trading/account/"
+
+
+class OkxClient(ExchangeBase):
+    ###########################################################
+    # region client parameters
+    okx_api_base_host: str = "https://www.okx.com"
+    okx_api_base_url: str = "https://www.okx.com"
+    okx_api_v5_url: str = "https://www.okx.com/priapi/v5"
+    origin_header: str = "https://www.okx.com"
+
+    # endregion
+    ###########################################################
+    # region client constructor
+    def __init__(
+        self,
+        account_name: str = "default",
+        http_verify: bool = True,
+        fav_letter: str = "^",
+        read_session_file: bool = False,
+        sessions_dir: str = "sessions",
+        use_http1: bool = True,
+        use_http2: bool = False,
+    ):
+        # it looks like hyperliquid's api endpoints don't support http2 :(
+        self.httpx_client = httpx.AsyncClient(
+            verify=http_verify,
+            http1=use_http1,
+            http2=use_http2,
+        )
+        self.account_name = account_name
+        self._fav_letter = fav_letter
+        self.sessions_dir = sessions_dir
+        self.exchange_name = "okx"
+
+        super().__init__()
+
+        if read_session_file:
+            self.read_from_session_file(f"{sessions_dir}/{self.account_name}.okx")
+
+    # endregion
+    ###########################################################
+    # region positions endpoints
+    async def get_trader_positions(
+        self,
+        uid: int | str,
+    ) -> CurrentUserPositionsResponse:
+        params = {
+            "uniqueName": f"{uid}",
+            "t": f"{int(time.time() * 1000)}",
+        }
+        headers = self.get_headers()
+        return await self.invoke_get(
+            f"{self.okx_api_v5_url}/ecotrade/public/community/user/position-current",
+            headers=headers,
+            params=params,
+            model_type=CurrentUserPositionsResponse,
+        )
+
+    # endregion
+    ###########################################################
+    # region another-thing
+
+    async def get_copy_trader_info(
+        self,
+        uid: int | str,
+    ) -> UserInfoInitialProps:
+        params = {
+            "tab": "trade",
+        }
+        headers = self.get_headers()
+        result: bytes = await self.invoke_get(
+            f"{self.okx_api_base_host}/copy-trading/account/{uid}",
+            headers=headers,
+            params=params,
+            model_type=AppContextUserInfo,
+            raw_data=True,
+        )
+        parser = UserInfoHtmlParser("__app_data_for_ssr__")
+        parser.feed(result.decode("utf-8"))
+        if not parser.found_value:
+            raise ValueError("Okx API returned invalid response")
+
+        return AppContextUserInfo(
+            **(json.loads(parser.found_value)["appContext"]),
+        ).initial_props
+
+    # endregion
+    ###########################################################
+    # region client helper methods
+    def get_headers(self, payload=None, needs_auth: bool = False) -> dict:
+        the_headers = {
+            # "Host": self.hyperliquid_api_base_host,
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            "Accept-Encoding": "gzip, deflate, br, zstd",
+            "User-Agent": self.user_agent,
+            "Connection": "close",
+            "appsiteid": "0",
+        }
+
+        if self.x_requested_with:
+            the_headers["X-Requested-With"] = self.x_requested_with
+
+        if needs_auth:
+            the_headers["Authorization"] = f"Bearer {self.authorization_token}"
+        return the_headers
+
+    def read_from_session_file(self, file_path: str) -> None:
+        """
+        Reads from session file; if it doesn't exist, creates it.
+        """
+        # check if path exists
+        target_path = Path(file_path)
+        if not target_path.exists():
+            return self._save_session_file(file_path=file_path)
+
+        aes = AESCipher(key=f"bf_{self.account_name}_bf", fav_letter=self._fav_letter)
+        content = aes.decrypt(target_path.read_text()).decode("utf-8")
+        json_data: dict = json.loads(content)
+
+        self.authorization_token = json_data.get(
+            "authorization_token",
+            self.authorization_token,
+        )
+        self.user_agent = json_data.get("user_agent", self.user_agent)
+
+    def _save_session_file(self, file_path: str) -> None:
+        """
+        Saves current information to the session file.
+        """
+
+        json_data = {
+            "authorization_token": self.authorization_token,
+            "user_agent": self.user_agent,
+        }
+        aes = AESCipher(key=f"bf_{self.account_name}_bf", fav_letter=self._fav_letter)
+        target_path = Path(file_path)
+        if not target_path.exists():
+            target_path.mkdir(parents=True)
+        target_path.write_text(aes.encrypt(json.dumps(json_data)))
+
+    # endregion
+    ###########################################################
+    # region unified methods
+    async def get_unified_trader_positions(
+        self,
+        uid: int | str,
+        min_margin: Decimal = 0,
+    ) -> UnifiedTraderPositions:
+        result = await self.get_trader_positions(
+            uid=uid,
+        )
+        unified_result = UnifiedTraderPositions()
+        unified_result.positions = new_list()
+        for position in result.data[0].pos_data:
+            if min_margin and (not position.margin or position.margin < min_margin):
+                continue
+            unified_pos = UnifiedPositionInfo()
+            unified_pos.position_id = position.pos_id
+            unified_pos.position_pnl = round(position.realized_pnl, 3)
+            unified_pos.position_side = position.get_side()
+            unified_pos.margin_mode = position.mgn_mode
+            unified_pos.position_leverage = position.lever
+            unified_pos.position_pair = position.get_pair()
+            unified_pos.open_time = position.c_time
+            unified_pos.open_price = position.avg_px
+            unified_pos.open_price_unit = position.quote_ccy
+            unified_pos.initial_margin = position.margin
+            unified_result.positions.append(unified_pos)
+
+        return unified_result
+
+    async def get_unified_trader_info(
+        self,
+        uid: int | str,
+    ) -> UnifiedTraderInfo:
+        result = await self.get_copy_trader_info(
+            uid=uid,
+        )
+        account_info = result.pre_process.leader_account_info
+        overview = result.overview_data
+
+        unified_info = UnifiedTraderInfo()
+        unified_info.trader_id = account_info.unique_name or uid
+        unified_info.trader_name = account_info.en_nick_name or account_info.nick_name
+        unified_info.trader_url = f"{BASE_PROFILE_URL}{uid}"
+        if overview:
+            unified_info.win_rate = overview.win_rate
+
+        return unified_info
+
+    # endregion
+    ###########################################################

trd_utils/exchanges/okx/okx_types.py

@@ -0,0 +1,197 @@
+from datetime import datetime
+from decimal import Decimal
+from html.parser import HTMLParser
+from typing import Any
+from trd_utils.types_helper import BaseModel
+
+
+###########################################################
+
+# region common types
+
+
+class OkxApiResponse(BaseModel):
+    code: int = None
+    msg: str = None
+
+    def __str__(self):
+        return f"code: {self.code}; timestamp: {self.timestamp}; {getattr(self, 'data', None)}"
+
+    def __repr__(self):
+        return self.__str__()
+
+
+# endregion
+
+###########################################################
+
+# region user-positions types
+
+
+class UserPositionInfo(BaseModel):
+    alias: str = None
+    avg_px: Decimal = None
+    be_px: Decimal = None
+    c_time: datetime = None
+    fee: Decimal = None
+    funding_fee: Decimal = None
+    inst_id: str = None
+    inst_type: str = None
+    last: Decimal = None
+    lever: Decimal = None
+    liq_px: Decimal = None
+    margin: Decimal = None
+    mark_px: Decimal = None
+    mgn_mode: str = None
+    mgn_ratio: Decimal = None
+    notional_usd: Decimal = None
+    pnl: Decimal = None
+    pos: Decimal = None
+    pos_ccy: str = None
+    pos_id: str = None
+    pos_side: str = None  # not that position side
+    quote_ccy: str = None
+    realized_pnl: Decimal = None
+    upl: Decimal = None
+    upl_ratio: Decimal = None
+
+    def get_side(self) -> str:
+        if self.pos > 0:
+            return "LONG"
+        return "SHORT"
+    
+    def get_pair(self) -> str:
+        my_inst = self.inst_id.split("-")
+        if len(my_inst) > 1:
+            if my_inst[1] == "USD":
+                my_inst[1] = "USDT"
+
+            return f"{my_inst[0]}/{my_inst[1]}"
+        # fallback to USDT
+        return f"{self.pos_ccy}/USDT"
+        
+
+
+class CurrentUserPositionsResult(BaseModel):
+    long_lever: Decimal = None
+    short_lever: Decimal = None
+    pos_data: list[UserPositionInfo] = None
+
+
+class CurrentUserPositionsResponse(OkxApiResponse):
+    data: list[CurrentUserPositionsResult] = None
+
+
+# endregion
+
+###########################################################
+
+# region User Info types
+
+
+class UserOverviewData(BaseModel):
+    ccy: str = None
+    equity: Decimal = None
+    max_retreat: Decimal = None
+    onboard_duration: int = None
+    pnl: Decimal = None
+    pnl_ratio: Decimal = None
+    risk_reward_ratio: str = None
+    win_rate: Decimal = None
+    withdrawal: Decimal = None
+
+
+class AuthInfo(BaseModel):
+    is_new_user: bool = None
+    user_guidance: bool = None
+    is_show_smart_copy: bool = None
+    is_cr_market_white_list_user: bool = None
+    is_show_min_entry_mount: bool = None
+    is_show_trader_tier: bool = None
+    auth_info_has_loaded: bool = None
+
+
+class LeaderAccountInfo(BaseModel):
+    unique_name: str = None
+    api_trader: int = None
+    portrait: str = None
+    nick_name: str = None
+    en_nick_name: str = None
+    sign: str = None
+    translated_bio: str = None
+    en_sign: str = None
+    day: int = None
+    count: str = None
+    followee_num: int = None
+    target_id: str = None
+    role_type: int = None
+    spot_role_type: int = None
+    public_status: int = None
+    country_id: str = None
+    is_strategy_lead: bool = None
+    is_signal_trader: bool = None
+    country_name: str = None
+    show_country_tag: bool = None
+    is_chinese: bool = None
+    is_followed: bool = None
+    tier: Any = None
+
+
+class PreProcessUerInfo(BaseModel):
+    leader_account_info: LeaderAccountInfo = None
+    auth_info: AuthInfo = None
+
+
+class UserInfoInitialProps(BaseModel):
+    overview_data: UserOverviewData = None
+    pre_process: PreProcessUerInfo = None
+
+
+class AppContextUserInfo(BaseModel):
+    """
+    The class which holds an AppContext related to a certain user's info
+    on the exchange.
+    """
+
+    initial_props: UserInfoInitialProps = None
+    is_ssr: bool = None
+    faas_use_ssr: bool = None
+    use_ssr: bool = None
+    is_ssr_success: bool = None
+    dsn: str = None
+    template_config: None = None
+    version: str = None
+    project: str = None
+    url_key: str = None
+    trace_id: str = None
+    enable_rtl: bool = None
+    is_apm_proxy_off: int = None
+    is_yandex_off: int = None
+    is_web_worker_enable: int = None
+
+
+class UserInfoHtmlParser(HTMLParser):
+    target_data_id: str = None
+    found_value: str = None
+    current_tag_has_target: bool = None
+
+    def __init__(self, target_data_id: str, **kwargs):
+        super().__init__(**kwargs)
+        self.target_data_id = target_data_id
+        self.found_value = None
+        self.current_tag_has_target = False
+
+    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]):
+        attrs_dict = dict(attrs)
+        if "data-id" in attrs_dict and attrs_dict["data-id"] == self.target_data_id:
+            self.current_tag_has_target = True
+
+    def handle_data(self, data: str):
+        if self.current_tag_has_target:
+            self.found_value = data
+            self.current_tag_has_target = False
+
+
+# endregion
+
+###########################################################

trd_utils/exchanges/price_fetcher.py

@@ -0,0 +1,48 @@
+
+
+from datetime import datetime
+from decimal import Decimal
+
+import pytz
+from trd_utils.types_helper import BaseModel
+
+
+class MinimalCandleInfo(BaseModel):
+    # The pair in format of BTC/USDT.
+    pair: str = None
+
+    # This candle's open price.
+    open_price: Decimal = None
+
+    # The close price.
+    close_price: Decimal = None
+
+    # volume in the first pair (e.g. BTC).
+    volume: Decimal = None
+
+    # volume in the second part of the pair (e.g. USDT).
+    quote_volume: Decimal = None
+
+    # The time this candle info was retrieved.
+    fetched_at: datetime = None
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.fetched_at = datetime.now(tz=pytz.UTC)
+
+
+class IPriceFetcher:
+    """
+    The IPriceFetcher class acts as an interface for classes that support
+    fetching last candle of a specific pair, without any specific floodwait or
+    ratelimit applied on the method itself (because e.g. they are fetching it
+    through a background websocket connection).
+    Please do not use this class directly, instead use a class that inherits
+    and implements the methods of this class (e.g. one of the exchange classes).
+    """
+
+    async def do_price_subscribe(self) -> None:
+        pass
+
+    async def get_last_candle(self, pair: str) -> MinimalCandleInfo:
+        pass

trd_utils/html_utils/__init__.py

@@ -0,0 +1,26 @@
+
+from .html_formats import (
+    get_html_normal,
+    html_normal,
+    html_mono,
+    html_in_parenthesis,
+    html_bold,
+    html_italic,
+    html_link,
+    html_code_snippets,
+    html_pre,
+    html_spoiler
+)
+
+__all__ = [
+    "get_html_normal",
+    "html_normal",
+    "html_mono",
+    "html_in_parenthesis",
+    "html_bold",
+    "html_italic",
+    "html_link",
+    "html_code_snippets",
+    "html_pre",
+    "html_spoiler"
+]