pybinbot 0.4.0__py3-none-any.whl → 0.4.15__py3-none-any.whl

pybinbot/apis/binbot/base.py

@@ -0,0 +1,327 @@
+import os
+
+from aiohttp import ClientSession
+from dotenv import load_dotenv
+from pybinbot import ExchangeId, Status
+from requests import Session
+from pybinbot import BinanceApi, handle_binance_errors, aio_response_handler
+
+load_dotenv()
+
+
+class BinbotApi:
+    """
+    API endpoints on this project itself
+    includes Binance Api
+    """
+
+    bb_base_url = os.getenv("BACKEND_DOMAIN", "https://api.terminal.binbot.in")
+    bb_symbols_raw = f"{bb_base_url}/account/symbols"
+    bb_bot_url = f"{bb_base_url}/bot"
+    bb_activate_bot_url = f"{bb_base_url}/bot/activate"
+    bb_gainers_losers = f"{bb_base_url}/account/gainers-losers"
+    bb_market_domination = f"{bb_base_url}/charts/market-domination"
+    bb_top_gainers = f"{bb_base_url}/charts/top-gainers"
+    bb_top_losers = f"{bb_base_url}/charts/top-losers"
+    bb_btc_correlation_url = f"{bb_base_url}/charts/btc-correlation"
+    bb_timeseries_url = f"{bb_base_url}/charts/timeseries"
+    bb_adr_series_url = f"{bb_base_url}/charts/adr-series"
+
+    # Trade operations
+    bb_buy_order_url = f"{bb_base_url}/order/buy"
+    bb_tp_buy_order_url = f"{bb_base_url}/order/buy/take-profit"
+    bb_buy_market_order_url = f"{bb_base_url}/order/buy/market"
+    bb_sell_order_url = f"{bb_base_url}/order/sell"
+    bb_tp_sell_order_url = f"{bb_base_url}/order/sell/take-profit"
+    bb_sell_market_order_url = f"{bb_base_url}/order/sell/market"
+    bb_opened_orders_url = f"{bb_base_url}/order/open"
+    bb_close_order_url = f"{bb_base_url}/order/close"
+    bb_stop_buy_order_url = f"{bb_base_url}/order/buy/stop-limit"
+    bb_stop_sell_order_url = f"{bb_base_url}/order/sell/stop-limit"
+    bb_submit_errors = f"{bb_base_url}/bot/errors"
+    bb_pt_submit_errors_url = f"{bb_base_url}/paper-trading/errors"
+    bb_liquidation_url = f"{bb_base_url}/account/one-click-liquidation"
+
+    # balances
+    bb_balance_url = f"{bb_base_url}/account/balance"
+    bb_balance_series_url = f"{bb_base_url}/account/balance/series"
+    bb_kucoin_balance_url = f"{bb_base_url}/account/kucoin-balance"
+
+    # research
+    bb_autotrade_settings_url = f"{bb_base_url}/autotrade-settings/bots"
+    bb_blacklist_url = f"{bb_base_url}/research/blacklist"
+    bb_symbols = f"{bb_base_url}/symbols"
+    bb_one_symbol_url = f"{bb_base_url}/symbol"
+
+    # bots
+    bb_active_pairs = f"{bb_base_url}/bot/active-pairs"
+
+    # paper trading
+    bb_test_bot_url = f"{bb_base_url}/paper-trading"
+    bb_paper_trading_url = f"{bb_base_url}/paper-trading"
+    bb_activate_test_bot_url = f"{bb_base_url}/paper-trading/activate"
+    bb_paper_trading_activate_url = f"{bb_base_url}/paper-trading/activate"
+    bb_paper_trading_deactivate_url = f"{bb_base_url}/paper-trading/deactivate"
+    bb_test_bot_active_list = f"{bb_base_url}/paper-trading/active-list"
+    bb_test_autotrade_url = f"{bb_base_url}/autotrade-settings/paper-trading"
+    bb_test_active_pairs = f"{bb_base_url}/paper-trading/active-pairs"
+
+    def request(self, url, method="GET", session: Session = Session(), **kwargs):
+        res = session.request(url=url, method=method, **kwargs)
+        data = handle_binance_errors(res)
+        return data
+
+    """
+    Async HTTP client/server for asyncio
+    that replaces requests library
+    """
+
+    async def fetch(self, url, method="GET", **kwargs):
+        async with ClientSession() as session:
+            async with session.request(method=method, url=url, **kwargs) as response:
+                data = await aio_response_handler(response)
+                return data
+
+    def get_symbols(self) -> list[dict]:
+        response = self.request(url=self.bb_symbols)
+        return response["data"]
+
+    def get_single_symbol(self, symbol: str) -> dict:
+        response = self.request(url=f"{self.bb_one_symbol_url}/{symbol}")
+        return response["data"]
+
+    async def get_market_breadth(self, size=400):
+        """
+        Get market breadth data
+        """
+        response = await self.fetch(url=self.bb_adr_series_url, params={"size": size})
+        if "data" in response:
+            return response["data"]
+        return None
+
+    def get_latest_btc_price(self):
+        binance_api = BinanceApi()
+        # Get 24hr last BTCUSDC
+        btc_ticker_24 = binance_api.get_ticker_price("BTCUSDC")
+        self.btc_change_perc = float(btc_ticker_24["priceChangePercent"])
+        return self.btc_change_perc
+
+    def post_error(self, msg):
+        data = self.request(
+            method="PUT", url=self.bb_autotrade_settings_url, json={"system_logs": msg}
+        )
+        return data
+
+    def get_test_autotrade_settings(self):
+        data = self.request(url=self.bb_test_autotrade_url)
+        return data["data"]
+
+    def get_autotrade_settings(self) -> dict:
+        data = self.request(url=self.bb_autotrade_settings_url)
+        return data["data"]
+
+    def get_bots_by_status(
+        self,
+        start_date,
+        end_date,
+        collection_name="bots",
+        status=Status.active,
+    ):
+        url = self.bb_bot_url
+        if collection_name == "paper_trading":
+            url = self.bb_test_bot_url
+
+        data = self.request(
+            url=url,
+            params={
+                "status": status.value,
+                "start_date": start_date,
+                "end_date": end_date,
+            },
+        )
+        return data["data"]
+
+    def submit_bot_event_logs(self, bot_id, message):
+        data = self.request(
+            url=f"{self.bb_submit_errors}/{bot_id}",
+            method="POST",
+            json={"errors": message},
+        )
+        return data
+
+    def submit_paper_trading_event_logs(self, bot_id, message):
+        data = self.request(
+            url=f"{self.bb_pt_submit_errors_url}/{bot_id}",
+            method="POST",
+            json={"errors": message},
+        )
+        return data
+
+    def add_to_blacklist(self, symbol, reason=None):
+        payload = {"symbol": symbol, "reason": reason}
+        data = self.request(url=self.bb_blacklist_url, method="POST", json=payload)
+        return data
+
+    def clean_margin_short(self, pair):
+        """
+        Liquidate and disable margin_short trades
+        """
+        data = self.request(url=f"{self.bb_liquidation_url}/{pair}", method="DELETE")
+        return data
+
+    def delete_bot(self, bot_id: str | list[str]):
+        bot_ids = []
+        if isinstance(bot_id, str):
+            bot_ids.append(bot_id)
+
+        data = self.request(
+            url=f"{self.bb_bot_url}", method="DELETE", params={"id": bot_ids}
+        )
+        return data
+
+    def get_balances(self):
+        data = self.request(url=self.bb_balance_url)
+        return data
+
+    def get_balances_by_type(self):
+        data = self.request(url=self.bb_kucoin_balance_url)
+        return data
+
+    def get_available_fiat(
+        self, exchange: str, fiat: str = "USDT", is_margin=False
+    ) -> float:
+        if exchange == ExchangeId.KUCOIN.value:
+            all_balances = self.get_balances_by_type()
+            available_fiat = 0.0
+
+            for item in all_balances["data"]["balances"]:
+                if is_margin:
+                    if item == "margin":
+                        for key in all_balances["data"]["balances"]["margin"]:
+                            if key == fiat:
+                                available_fiat += float(
+                                    all_balances["data"]["balances"]["margin"][key]
+                                )
+                else:
+                    if item == "trade":
+                        for key in all_balances["data"]["balances"]["trade"]:
+                            if key == fiat:
+                                available_fiat += float(
+                                    all_balances["data"]["balances"]["trade"][key]
+                                )
+
+                if item == "main":
+                    for key in all_balances["data"]["balances"]["main"]:
+                        if key == fiat:
+                            available_fiat += float(
+                                all_balances["data"]["balances"]["main"][key]
+                            )
+
+            return float(all_balances["data"]["fiat_available"])
+        else:
+            all_balances = self.get_balances()
+            return float(all_balances["data"]["fiat_available"])
+
+    def create_bot(self, data):
+        data = self.request(url=self.bb_bot_url, method="POST", data=data)
+        return data
+
+    def activate_bot(self, bot_id):
+        data = self.request(url=f"{self.bb_activate_bot_url}/{bot_id}")
+        return data
+
+    def create_paper_bot(self, data):
+        data = self.request(url=self.bb_test_bot_url, method="POST", data=data)
+        return data
+
+    def activate_paper_bot(self, bot_id):
+        data = self.request(url=f"{self.bb_activate_test_bot_url}/{bot_id}")
+        return data
+
+    def delete_paper_bot(self, bot_id):
+        bot_ids = []
+        if isinstance(bot_id, str):
+            bot_ids.append(bot_id)
+
+        data = self.request(
+            url=f"{self.bb_test_bot_url}", method="DELETE", data={"id": bot_ids}
+        )
+        return data
+
+    def get_active_pairs(self, collection_name="bots"):
+        """
+        Get distinct (non-repeating) bots by status active
+        """
+        url = self.bb_active_pairs
+        if collection_name == "paper_trading":
+            url = self.bb_test_active_pairs
+
+        res = self.request(
+            url=url,
+        )
+
+        if res["data"] is None:
+            return []
+
+        return res["data"]
+
+    def filter_excluded_symbols(self) -> list[str]:
+        """
+        all symbols that are active, not blacklisted
+        minus active bots
+        minus all symbols that match base asset of these active bots
+        i.e. BTC in BTCUSDC
+        """
+        active_pairs = self.get_active_pairs()
+        all_symbols = self.get_symbols()
+        exclusion_list = []
+        exclusion_list.extend(active_pairs)
+
+        for s in all_symbols:
+            for ap in active_pairs:
+                if (
+                    ap.startswith(s["base_asset"]) and s["id"] not in exclusion_list
+                ) or (not s["active"]):
+                    exclusion_list.append(s["id"])
+
+        return exclusion_list
+
+    async def get_top_gainers(self):
+        """
+        Top crypto/token/coin gainers of the day
+        """
+        response = await self.fetch(url=self.bb_top_gainers)
+        return response["data"]
+
+    async def get_top_losers(self):
+        """
+        Top crypto/token/coin losers of the day
+        """
+        response = await self.fetch(url=self.bb_top_losers)
+        return response["data"]
+
+    def get_btc_correlation(self, symbol) -> tuple[float, float]:
+        """
+        Get BTC correlation and 24hr price change
+        """
+        response = self.request(
+            url=self.bb_btc_correlation_url, params={"symbol": symbol}
+        )
+        data = response["data"]
+        correlation = float(data["correlation"])
+        price_change_24hr = float(data["24hr_price_change"])
+        return correlation, price_change_24hr
+
+    def price_precision(self, symbol) -> int:
+        """
+        Get price decimals from API db
+        """
+        symbol_info = self.get_single_symbol(symbol)
+        return symbol_info["price_precision"]
+
+    def qty_precision(self, symbol) -> int:
+        """
+        Get qty decimals from API db
+        """
+        symbol_info = self.get_single_symbol(symbol)
+        return symbol_info["qty_precision"]

pybinbot/apis/binbot/exceptions.py

@@ -0,0 +1,56 @@
+class BinbotErrors(Exception):
+    def __init__(self, msg, code=None):
+        self.message = msg
+        self.code = code
+        super().__init__(self.message)
+        return None
+
+    def __str__(self) -> str:
+        return f"{self.message}"
+
+
+class IsolateBalanceError(BinbotErrors):
+    pass
+
+
+class QuantityTooLow(BinbotErrors):
+    """
+    Raised when LOT_SIZE filter error triggers
+    This error should happen in the least cases,
+    unless purposedly triggered to check quantity
+    e.g. BTC = 0.0001 amounts are usually so small that it's hard to see if it's nothing or a considerable amount compared to others
+    """
+
+    pass
+
+
+class MarginShortError(BinbotErrors):
+    pass
+
+
+class MarginLoanNotFound(BinbotErrors):
+    pass
+
+
+class DeleteOrderError(BinbotErrors):
+    pass
+
+
+class LowBalanceCleanupError(BinbotErrors):
+    pass
+
+
+class DealCreationError(BinbotErrors):
+    pass
+
+
+class SaveBotError(BinbotErrors):
+    pass
+
+
+class InsufficientBalance(BinbotErrors):
+    """
+    Insufficient total_buy_qty to deactivate
+    """
+
+    pass

pybinbot/apis/kucoin/base.py

@@ -0,0 +1,208 @@
+from kucoin_universal_sdk.generate.spot.market import (
+    GetPartOrderBookReqBuilder,
+    GetAllSymbolsReqBuilder,
+    GetSymbolReqBuilder,
+)
+from kucoin_universal_sdk.generate.account.account import (
+    GetSpotAccountListReqBuilder,
+    GetIsolatedMarginAccountReqBuilder,
+)
+from kucoin_universal_sdk.generate.account.account.model_get_isolated_margin_account_resp import (
+    GetIsolatedMarginAccountResp,
+)
+from kucoin_universal_sdk.generate.account.transfer.model_flex_transfer_req import (
+    FlexTransferReq,
+    FlexTransferReqBuilder,
+)
+from kucoin_universal_sdk.generate.account.transfer.model_flex_transfer_resp import (
+    FlexTransferResp,
+)
+from uuid import uuid4
+from pybinbot.apis.kucoin.orders import KucoinOrders
+
+
+class KucoinApi(KucoinOrders):
+    def __init__(self, key: str, secret: str, passphrase: str):
+        super().__init__(key=key, secret=secret, passphrase=passphrase)
+        self.account_api = (
+            self.client.rest_service().get_account_service().get_account_api()
+        )
+
+    def get_all_symbols(self):
+        request = GetAllSymbolsReqBuilder().build()
+        response = self.spot_api.get_all_symbols(request)
+        return response
+
+    def get_symbol(self, symbol: str):
+        """
+        Get single symbol data
+        """
+        request = GetSymbolReqBuilder().set_symbol(symbol).build()
+        response = self.spot_api.get_symbol(request)
+        return response
+
+    def get_ticker_price(self, symbol: str) -> float:
+        request = GetPartOrderBookReqBuilder().set_symbol(symbol).set_size("1").build()
+        response = self.spot_api.get_ticker(request)
+        return float(response.price)
+
+    def get_account_balance(self):
+        """
+        Aggregate all balances from all account types (spot, main, trade, margin, futures).
+
+        The right data shape for Kucion should be provided by
+        get_account_balance_by_type method.
+
+        However, this method provides a normalized version for backwards compatibility (Binance) and consistency with current balances table.
+
+        Returns a dict:
+            {
+                asset:
+                    {
+                        total: float,
+                        breakdown:
+                            {
+                                    account_type: float, ...
+                            }
+                    }
+            }
+        """
+        spot_request = GetSpotAccountListReqBuilder().build()
+        all_accounts = self.account_api.get_spot_account_list(spot_request)
+        balance_items = dict()
+        for item in all_accounts.data:
+            if float(item.balance) > 0:
+                balance_items[item.currency] = {
+                    "balance": float(item.balance),
+                    "free": float(item.available),
+                    "locked": float(item.holds),
+                }
+
+        margin_request = GetIsolatedMarginAccountReqBuilder().build()
+        margin_accounts = self.account_api.get_isolated_margin_account(margin_request)
+        if float(margin_accounts.total_asset_of_quote_currency) > 0:
+            balance_items["USDT"]["balance"] += float(
+                margin_accounts.total_asset_of_quote_currency
+            )
+
+        return balance_items
+
+    def get_account_balance_by_type(self) -> dict[str, dict[str, dict[str, float]]]:
+        """
+        Get balances grouped by account type.
+        Returns:
+            {
+                'MAIN': {'USDT': {...}, 'BTC': {...}, ...},
+                'TRADE': {'USDT': {...}, ...},
+                'MARGIN': {...},
+                ...
+            }
+        Each currency has: balance (total), available, holds
+        """
+        spot_request = GetSpotAccountListReqBuilder().build()
+        all_accounts = self.account_api.get_spot_account_list(spot_request)
+
+        balance_by_type: dict[str, dict[str, dict[str, float]]] = {}
+        for item in all_accounts.data:
+            if float(item.balance) > 0:
+                account_type = item.type  # MAIN, TRADE, MARGIN, etc.
+                if account_type not in balance_by_type:
+                    balance_by_type[account_type] = {}
+                balance_by_type[account_type][item.currency] = {
+                    "balance": float(item.balance),
+                    "available": float(item.available),
+                    "holds": float(item.holds),
+                }
+
+        return balance_by_type
+
+    def get_single_spot_balance(self, asset: str) -> float:
+        spot_request = GetSpotAccountListReqBuilder().build()
+        all_accounts = self.account_api.get_spot_account_list(spot_request)
+        total_balance = 0.0
+        for item in all_accounts.data:
+            if item.currency == asset:
+                return float(item.balance)
+
+        return total_balance
+
+    def get_isolated_balance(self, symbol: str) -> GetIsolatedMarginAccountResp:
+        request = GetIsolatedMarginAccountReqBuilder().set_symbol(symbol).build()
+        response = self.account_api.get_isolated_margin_account(request)
+        return response
+
+    def transfer_isolated_margin_to_spot(
+        self, asset: str, symbol: str, amount: float
+    ) -> FlexTransferResp:
+        """
+        Transfer funds from isolated margin to spot (main) account.
+        `symbol` is the isolated pair like "BTC-USDT".
+        """
+        client_oid = str(uuid4())
+        req = (
+            FlexTransferReqBuilder()
+            .set_client_oid(client_oid)
+            .set_currency(asset)
+            .set_amount(str(amount))
+            .set_type(FlexTransferReq.TypeEnum.INTERNAL)
+            .set_from_account_type(FlexTransferReq.FromAccountTypeEnum.ISOLATED)
+            .set_from_account_tag(symbol)
+            .set_to_account_type(FlexTransferReq.ToAccountTypeEnum.MAIN)
+            .build()
+        )
+        return self.transfer_api.flex_transfer(req)
+
+    def transfer_spot_to_isolated_margin(
+        self, asset: str, symbol: str, amount: float
+    ) -> FlexTransferResp:
+        """
+        Transfer funds from spot (main) account to isolated margin account.
+        `symbol` must be the isolated pair like "BTC-USDT".
+        """
+        client_oid = str(uuid4())
+        req = (
+            FlexTransferReqBuilder()
+            .set_client_oid(client_oid)
+            .set_currency(asset)
+            .set_amount(str(amount))
+            .set_type(FlexTransferReq.TypeEnum.INTERNAL)
+            .set_from_account_type(FlexTransferReq.FromAccountTypeEnum.MAIN)
+            .set_to_account_type(FlexTransferReq.ToAccountTypeEnum.ISOLATED)
+            .set_to_account_tag(symbol)
+            .build()
+        )
+        return self.transfer_api.flex_transfer(req)
+
+    def transfer_main_to_trade(self, asset: str, amount: float) -> FlexTransferResp:
+        """
+        Transfer funds from main to trade (spot) account.
+        """
+        client_oid = str(uuid4())
+        req = (
+            FlexTransferReqBuilder()
+            .set_client_oid(client_oid)
+            .set_currency(asset)
+            .set_amount(str(amount))
+            .set_type(FlexTransferReq.TypeEnum.INTERNAL)
+            .set_from_account_type(FlexTransferReq.FromAccountTypeEnum.MAIN)
+            .set_to_account_type(FlexTransferReq.ToAccountTypeEnum.TRADE)
+            .build()
+        )
+        return self.transfer_api.flex_transfer(req)
+
+    def transfer_trade_to_main(self, asset: str, amount: float) -> FlexTransferResp:
+        """
+        Transfer funds from trade (spot) account to main.
+        """
+        client_oid = str(uuid4())
+        req = (
+            FlexTransferReqBuilder()
+            .set_client_oid(client_oid)
+            .set_currency(asset)
+            .set_amount(str(amount))
+            .set_type(FlexTransferReq.TypeEnum.INTERNAL)
+            .set_from_account_type(FlexTransferReq.FromAccountTypeEnum.TRADE)
+            .set_to_account_type(FlexTransferReq.ToAccountTypeEnum.MAIN)
+            .build()
+        )
+        return self.transfer_api.flex_transfer(req)

pybinbot/apis/kucoin/exceptions.py

@@ -0,0 +1,9 @@
+class KucoinErrors(Exception):
+    def __init__(self, msg, code):
+        self.code = code
+        self.message = msg
+        super().__init__(self.code, self.message)
+        return None
+
+    def __str__(self) -> str:
+        return f"{self.code}: {self.message}"

pybinbot/apis/kucoin/market.py

@@ -0,0 +1,92 @@
+from pybinbot.apis.kucoin.rest import KucoinRest
+from pybinbot import KucoinKlineIntervals
+from datetime import datetime
+from kucoin_universal_sdk.generate.spot.market import GetKlinesReqBuilder
+
+
+class KucoinMarket(KucoinRest):
+    """
+    Convienience wrapper for Kucoin order operations.
+
+    - Kucoin transactions don't immediately return all order details so we need cooldown slee
+    """
+
+    TRANSACTION_COOLDOWN_SECONDS = 1
+
+    def __init__(self, key: str, secret: str, passphrase: str):
+        super().__init__(key=key, secret=secret, passphrase=passphrase)
+        self.client = self.setup_client()
+        self.spot_api = self.client.rest_service().get_spot_service().get_market_api()
+        self.order_api = self.client.rest_service().get_spot_service().get_order_api()
+        self.margin_order_api = (
+            self.client.rest_service().get_margin_service().get_order_api()
+        )
+        self.debit_api = self.client.rest_service().get_margin_service().get_debit_api()
+        self.transfer_api = (
+            self.client.rest_service().get_account_service().get_transfer_api()
+        )
+
+    def get_ui_klines(
+        self,
+        symbol: str,
+        interval: str,
+        limit: int = 500,
+        start_time=None,
+        end_time=None,
+    ):
+        """
+        Get raw klines/candlestick data from Kucoin.
+
+        Args:
+            symbol: Trading pair symbol (e.g., "BTC-USDT")
+            interval: Kline interval (e.g., "15min", "1hour", "1day")
+            limit: Number of klines to retrieve (max 1500, default 500)
+            start_time: Start time in milliseconds (optional)
+            end_time: End time in milliseconds (optional)
+
+        Returns:
+            List of klines in format compatible with Binance format:
+            [timestamp, open, high, low, close, volume, close_time, ...]
+        """
+        # Compute time window based on limit and interval
+        interval_ms = KucoinKlineIntervals.get_interval_ms(interval)
+        now_ms = int(datetime.now().timestamp() * 1000)
+        # Align end_time to interval boundary
+        end_time = now_ms - (now_ms % interval_ms)
+        start_time = end_time - (limit * interval_ms)
+
+        builder = (
+            GetKlinesReqBuilder()
+            .set_symbol(symbol)
+            .set_type(interval)
+            .set_start_at(start_time // 1000)
+            .set_end_at(end_time // 1000)
+        )
+
+        request = builder.build()
+        response = self.spot_api.get_klines(request)
+
+        # Convert Kucoin format to Binance-compatible format
+        # Kucoin returns: [time, open, close, high, low, volume, turnover]
+        # Binance format: [open_time, open, high, low, close, volume, close_time, ...]
+        klines = []
+        if response.data:
+            for k in response.data:
+                # k format: [timestamp(seconds), open, close, high, low, volume, turnover]
+                open_time = int(k[0]) * 1000  # Convert to milliseconds
+                close_time = open_time + interval_ms  # Calculate proper close time
+                klines.append(
+                    [
+                        open_time,  # open_time in milliseconds
+                        k[1],  # open
+                        k[3],  # high
+                        k[4],  # low
+                        k[2],  # close
+                        k[5],  # volume base asset
+                        close_time,  # close_time properly calculated
+                        k[6],  # volume quote asset
+                    ]
+                )
+            klines.reverse()
+
+        return klines