%pip install pybit pandas python-dotenv

# pybit: Python SDK for Bybit API interactions.
# pandas: Data manipulation and analysis library.
# python-dotenv: Manages environment variables for API keys.

import os # Operating system interactions, e.g., environment variables
import time # Time-related functions, e.g., sleep
import datetime # Date and time manipulation
import pandas as pd # Data manipulation and analysis
from pybit.unified_trading import HTTP # Bybit Unified Trading API client
from pybit.exceptions import FailedRequestError # Import for Bybit API specific error handling
from requests.exceptions import ReadTimeout, ConnectionError, HTTPError # Exception handling for network errors
from dotenv import load_dotenv # Loads environment variables from a .env file

# Load environment variables from a .env file if present. This is used for API keys.
load_dotenv()

# SYMBOL: Trading pair for linear perpetual contracts.
SYMBOL          = "BTCUSDT"

# CATEGORY: Bybit product category (e.g., 'linear' for USDT perpetuals).
CATEGORY        = "linear"

# SIZE_PERCENT: Percentage of the available balance to allocate per trade order.
SIZE_PERCENT    = 10

# TP_PERCENT: Take-profit percentage relative to the entry price. Determines the target profit level.
TP_PERCENT      = 1.5

# SL_PERCENT: Stop-loss percentage relative to the entry price. Determines the maximum acceptable loss.
SL_PERCENT      = 0.8

# RECV_WINDOW: Request validity window in milliseconds. A higher value (e.g., 30000ms) mitigates clock skew issues, preventing API request rejection.
RECV_WINDOW     = 30000

def build_demo_client(recv_window: int = 30000) -> HTTP:
    """
    Create a Bybit HTTP client connected to the Demo Account environment.

    Parameters
    ----------
    recv_window : Request validity window in milliseconds.
                  Increase above default (5000) if clock sync issues occur.

    Returns
    -------
    pybit HTTP client instance in demo mode.
    """
    return HTTP(
        api_key    = "YOUR-API_KEY",
        api_secret = "YOUR-API-SECRET",
        demo       = True,
        recv_window= recv_window,
    )

def safe_request(fn, retries: int = 5, delay: float = 5.0):
    """
    Execute an API call with retry on transient network/API errors.

    Parameters
    ----------
    fn      : Zero-argument callable wrapping the API call.
    retries : Maximum retry attempts.
    delay   : Seconds to wait between retries.

    Notes
    -----
    Bybit returns the SAME 403 FailedRequestError for both a transient
    IP rate-limit hit and a permanent geo-compliance block (non-US IP
    required for demo/derivatives access). Retrying the latter is
    pointless and just burns more requests against the rate limit, so
    we inspect the error message and fail fast with a clear explanation
    when it's the geo-block case.
    """
    for attempt in range(retries):
        try:
            return fn()
        except (ReadTimeout, ConnectionError, HTTPError) as e:
            if attempt < retries - 1:
                print(f"[RETRY {attempt+1}] Network error: {e}. Retrying in {delay}s.")
                time.sleep(delay)
            else:
                raise e
        except FailedRequestError as e:
            message = str(getattr(e, "message", e)).lower()
            if "usa" in message:
                # Permanent compliance block — not fixable by retrying.
                raise RuntimeError(
                    "Bybit rejected this request because it believes it originated "
                    "from a US IP address. This is a regulatory block on Bybit's "
                    "side (demo/derivatives trading isn't available to US-located "
                    "accounts), not a bug in this notebook. Retrying will not help — "
                    "verify your network's egress location, or contact Bybit support "
                    "if you believe this is a false positive."
                ) from e
            if attempt < retries - 1:
                print(f"[RETRY {attempt+1}] API error: {e}. Retrying in {delay}s.")
                time.sleep(delay)
            else:
                raise e

def get_demo_balance(client: HTTP) -> float:
    """
    Retrieve the USDT equity balance from the Unified Demo Account.

    Returns
    -------
    Total account equity in USDT.
    """
    resp    = safe_request(lambda: client.get_wallet_balance(accountType="UNIFIED"))
    equity  = resp["result"]["list"][0]["totalEquity"]
    print(f"Demo Account Equity: {equity} USDT")
    return float(equity)

def get_instrument_info(client: HTTP, symbol: str) -> dict:
    """
    Retrieve tick size, step size, and order quantity limits for a symbol.

    Returns
    -------
    dict with keys: tick_size, step_size, min_qty, max_mkt_qty
    """
    resp = safe_request(lambda: client.get_instruments_info(category="linear", symbol=symbol))
    item = resp["result"]["list"][0]
    return {
        "tick_size":   float(item["priceFilter"]["tickSize"]),
        "step_size":   float(item["lotSizeFilter"]["qtyStep"]),
        "min_qty":     float(item["lotSizeFilter"]["minOrderQty"]),
        "max_mkt_qty": float(item["lotSizeFilter"]["maxMktOrderQty"]),
    }

def place_demo_market_order(client: HTTP, symbol: str,
                             side: str, qty: float) -> str:
    """
    Place a market order on the Bybit Demo Account.

    Parameters
    ----------
    client : Authenticated demo HTTP client.
    symbol : Ticker, e.g. 'BTCUSDT'.
    side   : 'Buy' | 'Sell'.
    qty    : Order quantity in base asset units.

    Returns
    -------
    Order ID string.
    """
    resp = safe_request(lambda: client.place_order(
        category="linear",
        symbol=symbol,
        side=side,
        orderType="Market",
        qty=str(qty),
    ))
    order_id = resp["result"]["orderId"]
    print(f"[ORDER] Market {side} | {qty} {symbol} | ID: {order_id}")
    return order_id

def place_demo_limit_order(client: HTTP, symbol: str,
                            side: str, qty: float, price: float) -> str:
    """
    Place a limit order on the Bybit Demo Account.

    Parameters
    ----------
    client : Authenticated demo HTTP client.
    symbol : Ticker.
    side   : 'Buy' | 'Sell'.
    qty    : Order quantity.
    price  : Limit price.

    Returns
    -------
    Order ID string.
    """
    resp = safe_request(lambda: client.place_order(
        category="linear",
        symbol=symbol,
        side=side,
        orderType="Limit",
        qty=str(qty),
        price=str(price),
        timeInForce="GTC",
    ))
    order_id = resp["result"]["orderId"]
    print(f"[ORDER] Limit {side} | {qty} {symbol} @ {price} | ID: {order_id}")
    return order_id

def get_open_demo_positions(client: HTTP, symbol: str) -> list:
    """Return active positions for the symbol on the demo account."""
    resp = safe_request(lambda: client.get_positions(category="linear", symbol=symbol))
    positions = resp["result"]["list"]
    return [p for p in positions if p.get("avgPrice", "0") not in ("", "0")]

def fetch_demo_transactions(client: HTTP, symbol: str,
                              start_date: str = None,
                              end_date:   str = None) -> pd.DataFrame:
    """
    Fetch transaction log and closed PnL data from the Bybit Demo Account.

    Implements date-range pagination in 7-day windows as required by the API.

    Parameters
    ----------
    client     : Authenticated demo HTTP client.
    symbol     : Asset symbol (without USDT suffix), e.g. 'BTC'.
    start_date : 'YYYY-MM-DD' string. Defaults to 2025-01-01.
    end_date   : 'YYYY-MM-DD' string. Defaults to now.

    Returns
    -------
    DataFrame of transactions with columns:
    datetime, type, symbol, qty, cashFlow, fee, side
    """
    from datetime import datetime, timedelta, timezone

    def to_ms(dt): return int(dt.timestamp() * 1000)

    start = datetime.strptime(start_date, "%Y-%m-%d") if start_date else datetime(2025, 1, 1)
    end   = datetime.strptime(end_date,   "%Y-%m-%d") if end_date   else datetime.now(timezone.utc).replace(tzinfo=None)

    transactions = []
    tx_types     = ["TRADE", "TRANSFER_IN", "TRANSFER_OUT"]

    current = start
    while current < end:
        next_window = min(current + timedelta(days=7), end)
        for tx_type in tx_types:
            cursor = None
            while True:
                params = {
                    "accountType": "UNIFIED",
                    "category":    "linear",
                    "currency":    "USDT",
                    "limit":       100,
                    "startTime":   to_ms(current),
                    "endTime":     to_ms(next_window),
                    "type":        tx_type,
                }
                if cursor:
                    params["cursor"] = cursor

                result  = safe_request(lambda: client.get_transaction_log(**params))
                tx_list = result.get("result", {}).get("list", [])

                if not tx_list:
                    break
                for tx in tx_list:
                    tx["transactionType"] = tx_type
                transactions.extend(tx_list)

                next_cursor = result.get("result", {}).get("nextPageCursor")
                if not next_cursor or next_cursor == cursor:
                    break
                cursor = next_cursor

        current = next_window

    df = pd.DataFrame(transactions)
    if not df.empty and "transactionTime" in df.columns:
        df["datetime"] = pd.to_datetime(df["transactionTime"], unit="ms")
    return df

def fetch_demo_transactions(client: HTTP, symbol: str,
                              start_date: str = None,
                              end_date:   str = None) -> pd.DataFrame:
    """
    Fetch transaction log and closed PnL data from the Bybit Demo Account.

    Implements date-range pagination in 7-day windows as required by the API.

    Parameters
    ----------jupyter notebook

    client     : Authenticated demo HTTP client.
    symbol     : Asset symbol (without USDT suffix), e.g. 'BTC'.
    start_date : 'YYYY-MM-DD' string. Defaults to 2025-01-01.
    end_date   : 'YYYY-MM-DD' string. Defaults to now.

    Returns
    -------
    DataFrame of transactions with columns:
    datetime, type, symbol, qty, cashFlow, fee, side
    """
    from datetime import datetime, timedelta, timezone

    def to_ms(dt): return int(dt.timestamp() * 1000)

    start = datetime.strptime(start_date, "%Y-%m-%d") if start_date else datetime(2025, 1, 1)
    end   = datetime.strptime(end_date,   "%Y-%m-%d") if end_date   else datetime.now(timezone.utc).replace(tzinfo=None)

    transactions = []
    tx_types     = ["TRADE", "TRANSFER_IN", "TRANSFER_OUT"]

    current = start
    while current < end:
        next_window = min(current + timedelta(days=7), end)
        for tx_type in tx_types:
            cursor = None
            while True:
                params = {
                    "accountType": "UNIFIED",
                    "category":    "linear",
                    "currency":    "USDT",
                    "limit":       100,
                    "startTime":   to_ms(current),
                    "endTime":     to_ms(next_window),
                    "type":        tx_type,
                }
                if cursor:
                    params["cursor"] = cursor

                result  = safe_request(lambda: client.get_transaction_log(**params))
                tx_list = result.get("result", {}).get("list", [])

                if not tx_list:
                    break
                for tx in tx_list:
                    tx["transactionType"] = tx_type
                transactions.extend(tx_list)

                next_cursor = result.get("result", {}).get("nextPageCursor")
                if not next_cursor or next_cursor == cursor:
                    break
                cursor = next_cursor

        current = next_window

    df = pd.DataFrame(transactions)
    if not df.empty and "transactionTime" in df.columns:
        df["datetime"] = pd.to_datetime(df["transactionTime"], unit="ms")
    return df

# Initialize the HTTP client for the demo trading environment.
client = build_demo_client()

# 1. Retrieve the current USDT balance from the demo account.
balance = get_demo_balance(client)

# 2. Obtain trading instrument metadata (e.g., tick size, step size, quantity limits).
info = get_instrument_info(client, SYMBOL)

# 3. Calculate the order quantity based on a percentage of the balance and instrument rules.
current_price  = float(safe_request(lambda: client.get_tickers(category="linear", symbol=SYMBOL))["result"]["list"][0]["markPrice"])
raw_qty        = (balance * SIZE_PERCENT / 100) / current_price
step_size_decimals = len(str(info["step_size"]).split(".")[1]) if '.' in str(info["step_size"]) else 0
qty            = round(raw_qty, step_size_decimals)

# 4. Place a market buy order for the calculated quantity.
order_id = place_demo_market_order(client, SYMBOL, "Buy", qty)
time.sleep(2)

# 5. Check for currently open positions for the specified symbol.
positions = get_open_demo_positions(client, SYMBOL)

# 6. If an open position exists, close it with a market sell order.
if positions:
    close_qty = float(positions[0]["size"])
    place_demo_market_order(client, SYMBOL, "Sell", close_qty)