I used this code: client = futures.HTTP(api_key=API_KEY_BINANCE, api_secret=API_SECRET_BINANCE)
symbol = 'BCHUSDT'
depth_data = client.get_depth(symbol=symbol)
print(depth_data)

start_row = 5  # Starting row index (inclusive)
end_row = 61  # Ending row index (exclusive)

print("Depth:")


balance_info = client.asset()

usdt_balance = None

for balance in balance_info:
    if balance['asset'] == 'USDT':
        usdt_balance = round(float(balance['balance']), 2)
                                   
if usdt_balance is not None:
    print("USDT Balance:", usdt_balance)
else:
    print("USDT balance not found.")

url = 'https://api.binance.com/api/v3/account'  # Replace with the appropriate Binance API endpoint

headers = {
    'X-MBX-APIKEY': API_KEY_BINANCE
}

timestamp = int(dt.datetime.now().timestamp() * 1000)  # Generate the current timestamp in milliseconds

# Create signature
params = urlencode({'timestamp': timestamp})
signature = hmac.new(API_SECRET_BINANCE.encode('utf-8'), params.encode('utf-8'), hashlib.sha256).hexdigest()

# Add signature and API key to request parameters
params += f'&signature={signature}'

# Make API request to check connection
response = requests.get(url, headers=headers, params=params)

# Check API response
if response.status_code == 200:
    print('Connected to the Binance API.')
else:
    print('Failed to connect to the Binance API.')
    print('Response:', response.text)

def get_klines(symbol, interval, lookback):
    API_KEY_BINANCE = 'your-api-key'  # Replace with your Binance API key
    symbol = symbol.replace("/", "")  # remove slash from symbol

    url = "https://api.binance.com/api/v3/klines"

    end_time = int(dt.datetime.now().timestamp() * 1000)  # end time is now
    start_time = end_time - (lookback * 60 * 1000)  # start time is lookback minutes ago

    params = {
        'symbol': symbol,
        'interval': interval,
        'startTime': start_time,
        'endTime': end_time
    }

    headers = {
        'X-MBX-APIKEY': API_KEY_BINANCE,
    }

    response = requests.get(url, params=params, headers=headers)
    response.raise_for_status()
    data = response.json()

    if not data:  # if data is empty, return None
        print('No data found for the given timeframe and symbol')
        return None

    ohlcv = []
    for d in data:
        timestamp = dt.datetime.fromtimestamp(d[0] / 1000).strftime('%Y-%m-%d %H:%M:%S')
        ohlcv.append({
            'Open time': timestamp,
            'Open': float(d[1]),
            'High': float(d[2]),
            'Low': float(d[3]),
            'Close': float(d[4]),
            'Volume': float(d[5])
        })

    df = pd.DataFrame(ohlcv)
    df.set_index('Open time', inplace=True)
    return df
interval = '1m'
lookback = 10080

df = get_klines(symbol, interval, lookback) 
# Import the necessary libraries

def signal_generator(df):
    if df is None or len(df) < 2:
        return ''

    signal = []
    
    # Retrieve depth data
    threshold = 0.35
    depth_data = client.get_depth(symbol=symbol)
    bid_depth = depth_data['bids']
    ask_depth = depth_data['asks']
    buy_price = float(bid_depth[0][0]) if bid_depth else 0.0
    sell_price = float(ask_depth[0][0]) if ask_depth else 0.0
    mark_price_data = client.ticker(symbol=symbol)
    mark_price = float(mark_price_data['price']) if 'price' in mark_price_data else 0.0

    buy_qty = float(bid_depth[0][1]) if bid_depth else 0.0
    sell_qty = float(ask_depth[0][1]) if ask_depth else 0.0

    if (sell_qty > (1 + threshold)) > buy_qty:
        signal.append('sell')
    elif (buy_qty > (1 + threshold)) > sell_qty:
        signal.append('buy')
    else:
        signal.append('')

    return signal

end_time = int(time.time() * 1000)
start_time = end_time - lookback * 60 * 1000
    
secret_key = API_KEY_BINANCE
access_key = API_SECRET_BINANCE 

import binance
import decimal  

balance_info = client.asset('USDT')

usdt_balance = None

for balance in balance_info:
    if balance['asset'] == 'USDT':
        usdt_balance = round(float(balance['balance']), 2)

def get_quantity(symbol, usdt_balance):
    try:
        mark_price_data = client.ticker(symbol=symbol)
        mark_price = float(mark_price_data['price']) if 'price' in mark_price_data else 0.0

        token_price = mark_price
        margin = 50
        quantity = round(float(usdt_balance) * margin / token_price, 2)
        return quantity
    except BinanceAPIException as e:
        print("Error executing long order:")
    return 0

print(get_quantity(symbol, usdt_balance))

while True:
    lookback = 10080
    df = get_klines(symbol, interval, lookback)

    if df is not None:
        signals = signal_generator(df)
        print(f"The signal time is: {dt.datetime.now().strftime('%Y-%m-%d %H:%M:%S')} - Signals: {signals}")
        mark_price = client.ticker(symbol=symbol)
        
        if signals == ['buy']:
            try:
                quantity = get_quantity(symbol, usdt_balance)
                client.order(symbol=symbol, side='BUY', type='MARKET', quantity=quantity)
                print("Long order executed!")
            except binance.error.ClientError as e:
                print(f"Error executing long order: {e}")
            
            time.sleep(1)

        if signals == ['sell']:
            try:
                quantity = get_quantity(symbol, usdt_balance)
                client.order(symbol=symbol, side='SELL', type='MARKET', quantity=quantity)
                print("Short order executed!")
            except binance.error.ClientError as e:
                print(f"Error executing short order: {e}")
            
            time.sleep(1)
    
    time.sleep(1)

Can you set them for `pymexc` please