I used your code: import time
from binance.client import Client
from binance.enums import *
from binance.exceptions import BinanceAPIException
from binance.helpers import round_step_size
import pandas as pd
import json
import numpy as np
import pytz
import datetime as dt
import ccxt
from decimal import Decimal
import requests
import hmac
import hashlib
API_KEY = ''
API_SECRET = ''

client = Client(API_KEY, API_SECRET)

# Set the endpoint and parameters for the request
url = "https://fapi.binance.com/fapi/v2/account"
timestamp = int(time.time() * 1000)
recv_window = 5000

params = {
    "timestamp": timestamp,
    "recvWindow": recv_window
}

# Sign the message using the Client’s secret key
message = '&'.join([f"{k}={v}" for k, v in params.items()])
signature = hmac.new(API_SECRET.encode(), message.encode(), hashlib.sha256).hexdigest()
params['signature'] = signature
leverage = 100

# Send the request using the requests library
response = requests.get(url, params=params, headers={'X-MBX-APIKEY': API_KEY})
account_info = response.json()

# Get the USDT balance and calculate the max trade size based on the leverage
usdt_balance = next((item for item in account_info['assets'] if item["asset"] == "USDT"), {"balance": 0})
max_trade_size = float(usdt_balance.get("balance", 0)) * leverage

# Get the current time and timestamp
now = dt.datetime.now()
date = now.strftime("%m/%d/%Y %H:%M:%S")
print(date)

timestamp = int(time.time() * 1000)

STOP_LOSS_PERCENTAGE = -50
TAKE_PROFIT_PERCENTAGE = 100
MAX_TRADE_QUANTITY_PERCENTAGE = 100
POSITION_SIDE_SHORT = 'SELL'
POSITION_SIDE_LONG = 'BUY'
quantity = 1
symbol = 'BTC/USDT'
order_type = 'market'
leverage = 100
max_trade_quantity_percentage = 1
binance_futures = ccxt.binance({
       'apiKey': API_KEY,
       'secret': API_SECRET,
       'enableRateLimit': True,  # enable rate limitation
       'options': {
           'defaultType': 'future',
           'adjustForTimeDifference': True
       },'future': {
            'sideEffectType': 'MARGIN_BUY', # MARGIN_BUY, AUTO_REPAY, etc…
        }
   })
# Load the market symbols

try:
    markets = binance_futures.load_markets()
except ccxt.BaseError as e:
    print(f'Error fetching markets: {e}')
    markets = []

if symbol in markets:
    print(f"{symbol} found in the market")
else:
    print(f"{symbol} not found in the market")

# Get server time and time difference

def get_server_time(exchange):
    server_time = exchange.fetch_currencies()
    return server_time['timestamp']

def get_time_difference():
    server_time = get_server_time(binance_futures)
    local_time = int(time.time() * 1000)
    time_difference = local_time - server_time
    return time_difference
time.sleep(1)

def get_klines(symbol, interval, lookback):
    url = "https://fapi.binance.com/fapi/v1/klines"
    end_time = int(time.time() * 1000) # end time is now
    start_time = end_time - (lookback * 60 * 1000) # start time is lookback minutes ago
    symbol = symbol.replace("/", "") # remove slash from symbol
    query_params = f"?symbol={symbol}&interval={interval}&startTime={start_time}&endTime={end_time}"
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36'
    }
    try:
        response = requests.get(url + query_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 
        ohlc = []
        for d in data:
            timestamp = dt.datetime.fromtimestamp(d[0]/1000).strftime('%Y-%m-%d %H:%M:%S')
            ohlc.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(ohlc)
        df.set_index('Open time', inplace=True)
        return df
    except requests.exceptions.RequestException as e:
        print(f'Error in get_klines: {e}')
    return None
df =  get_klines(symbol, '1m', 44640)

def signal_generator(df):
    if df is None:
        return ""
    open = df.Open.iloc[-1]
    close = df.Close.iloc[-1]
    previous_open = df.Open.iloc[-2]
    previous_close = df.Close.iloc[-2]

    # Bearish pattern
    if (open>close and
    previous_open<previous_close and
    close<previous_open and
    open>=previous_close):
        return 'sell'

    # Bullish pattern
    elif (open<close and
    previous_open>previous_close and
    close>previous_open and
    open<=previous_close):
        return 'buy'

    # No clear pattern
    else:
        return ""

df =  get_klines(symbol, '1m', 44640)
def order_execution(symbol, signal, step_size, leverage, order_type):
    # Close any existing positions
    current_position = None
    positions = binance_futures.fapiPrivateGetPositionRisk()
    for position in positions:
        if position["symbol"] == symbol:
            current_position = position
        if current_position is not None and current_position["positionAmt"] != 0:
            binance_futures.fapiPrivatePostOrder(
                symbol=symbol,
                side='SELL' if current_position["positionSide"] == "LONG" else 'BUY',
                type='MARKET',
                quantity=abs(float(current_position["positionAmt"])),
                positionSide=current_position["positionSide"],
                reduceOnly=True
            )
    time.sleep(1)

    # Calculate appropriate order quantity and price based on signal
    opposite_position = None
    quantity = step_size
    position_side = None #initialise to None
    price = None

    # Set default take profit price
    take_profit_price = None
    stop_loss_price = None

    if signal == 'buy':
        position_side = 'BOTH'
        opposite_position = current_position if current_position and current_position['positionSide'] == 'SHORT' else None
        order_type = 'TAKE_PROFIT_MARKET'
        ticker = binance_futures.fetch_ticker(symbol)
        price = 0 # default price
        if 'askPrice' in ticker:
            price = ticker['askPrice']
        # perform rounding and other operations on price
        else:
        # handle the case where the key is missing (e.g. raise an exception, skip this signal, etc.)
            take_profit_percentage = TAKE_PROFIT_PERCENTAGE
            stop_loss_percentage = STOP_LOSS_PERCENTAGE

    elif signal == 'sell':
        position_side = 'BOTH'
        opposite_position = current_position if current_position and current_position['positionSide'] == 'LONG' else None
        order_type = 'STOP_MARKET'
        ticker = binance_futures.fetch_ticker(symbol)
        price = 0 # default price
        if 'askPrice' in ticker:
            price = ticker['askPrice']
        # perform rounding and other operations on price
        else:
        # handle the case where the key is missing (e.g. raise an exception, skip this signal, etc.)
            take_profit_percentage = TAKE_PROFIT_PERCENTAGE
            stop_loss_percentage = STOP_LOSS_PERCENTAGE

    # Set stop loss price
    stop_loss_price = None
    if price is not None:
        try:
            price = round_step_size(price, step_size=step_size)
            if signal == 'buy':
                # Calculate take profit and stop loss prices for a buy signal
                take_profit_price = round_step_size(price * (1 + TAKE_PROFIT_PERCENTAGE / 100), step_size=step_size)
                stop_loss_price = round_step_size(price * (1 - STOP_LOSS_PERCENTAGE / 100), step_size=step_size)
            elif signal == 'sell':
            # Calculate take profit and stop loss prices for a sell signal
                take_profit_price = round_step_size(price * (1 - TAKE_PROFIT_PERCENTAGE / 100), step_size=step_size)
                stop_loss_price = round_step_size(price * (1 + STOP_LOSS_PERCENTAGE / 100), step_size=step_size)
        except Exception as e:
            print(f"Error rounding price: {e}")

    # Reduce quantity if opposite position exists
    if opposite_position is not None:
        if abs(opposite_position['positionAmt']) < quantity:
            quantity = abs(opposite_position['positionAmt'])

    # Update position_side based on opposite_position and current_position
    if opposite_position is not None:
        position_side = opposite_position['positionSide']
    elif current_position is not None:
        position_side = current_position['positionSide']


    # Place stop market order
    if order_type == 'STOP_MARKET':
        try:
            data = json.dumps({"symbol": symbol})
            response = binance_futures.fapiPrivatePostOrder(
                data=data,
                sideEffectType='MARGIN_BUY',
                type='MARKET' if signal == 'buy' else 'STOP_MARKET',
                quantity=quantity,
                positionSide=POSITION_SIDE_LONG if signal == 'buy' else POSITION_SIDE_SHORT,
                reduceOnly=True,
                newOrderRespType='FULL',
                stopPrice=stop_loss_price,
                price=price,
                workingType='MARK_PRICE',
                priceProtect=False,
                timeInForce='GTC',
                newClientOrderId=''
            )
            print(f"Order details: {response}")
        except BinanceAPIException as e:
            print(f"Error in order_execution: {e}")
        time.sleep(1)
        return

    # Place market or take profit order
    elif order_type == 'market':
        try:
            response = binance_futures.create_order(
                symbol=symbol,
                type=order_type,
                side='BUY' if signal == 'buy' else 'SELL',
                amount=quantity,
                price=price
            )
            print(f"Order details: {response}")
        except BinanceAPIException as e:
            print(f"Error in order_execution: {e}")
        time.sleep(1)
        return
signal = signal_generator(df)
while True:
    df = get_klines(symbol, '1m', 44640) # await the coroutine function here
    if df is not None:
        signal = signal_generator(df)
    if signal is not None:
        print(f"The signal time is: {dt.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}, signal:{signal}")
        if signal:
            order_execution(symbol, signal, MAX_TRADE_QUANTITY_PERCENTAGE, leverage, order_type)
        time.sleep(0.1)
But I getting ERROR: The signal time is: 2023-06-08 21:34:58, signal:buy
The signal time is: 2023-06-08 21:35:01, signal:sell
Traceback (most recent call last):
  File "c:\Users\Alan\.vscode\jew_bot\jew_bot\jew_bot.py", line 293, in <module>
    order_execution(symbol, signal, MAX_TRADE_QUANTITY_PERCENTAGE, leverage, order_type)
  File "c:\Users\Alan\.vscode\jew_bot\jew_bot\jew_bot.py", line 249, in order_execution
    response = binance_futures.fapiPrivatePostOrder(
               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
TypeError: Entry.__init__.<locals>.unbound_method() got an unexpected keyword argument 'data'