I used this 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
import ntplib
import os
import ta
API_KEY = ''

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
try:
    usdt_balance = next((item for item in account_info['accountBalance'] if item["asset"] == "USDT"), {"free": 0})['free']
except KeyError:
    usdt_balance = 0
    print("Error: Could not retrieve USDT balance from API response.")

max_trade_size = float(usdt_balance) * 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


def sync_time():
    ntp_client = ntplib.NTPClient()
    response = ntp_client.request('pool.ntp.org', version=3)
    now = time.time()
    offset = response.offset
    new_time = now + offset
    # Set the system clock to the new time
    os.system(f'sudo date -s @{int(new_time)}')
    print(f'New time: {dt.datetime.now()}')

recv_window = 10000
params = {
    "timestamp": timestamp,
    "recvWindow": recv_window
}
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):
    return exchange.fetch_time()

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'
    }
    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
df = get_klines(symbol, '1m', 44640)

# Define function to generate trading signals
def signal_generator(df):
    open = df.Open.iloc[-1]
    close = df.Close.iloc[-1]
    previous_open = df.Open.iloc[-2]
    previous_close = df.Close.iloc[-2]
    # Calculate EMA indicator
    ema = ta.trend.EMAIndicator(df['Close'], window=10)

    # Calculate MA indicator
    ma = ta.trend.SMAIndicator(df['Close'], window=20)

    # Calculate EMA indicator
    ema_value = ema.ema_indicator()[-1] #get the EMA indicator value for the last value in the DataFrame
    ma_value = ma.sma_indicator()[-1] #get the MA indicator value for the last value in the DataFrame

    #Bearish pattern with EMA and MA indicators
    if (open>close and
    previous_open<previous_close and
    close<previous_open and
    open>=previous_close and
    close<ema_value and close<ma_value):
        return 'sell'

    #Bullish pattern with EMA and MA indicators
    elif (open<close and
    previous_open>previous_close and
    close>previous_open and
    open<=previous_close and
    close>ema_value and close>ma_value):
        return 'buy'

    #No clear pattern with EMA and MA indicators
    else:
        return ''
df =  get_klines(symbol, '1m', 44640)

def order_execution(symbol, signal, step_size, leverage, order_type):
    # Set default value for response
    response = {}

    # 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:
            response = 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
            )

    if 'orderId' in response:
        print(f'Closed position: {response}')
    else:
        print(f'Error closing position: {response}')
    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 'ask' in ticker:
            price = ticker['ask']
        # 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 'bid' in ticker:
        price = ticker['bid']
    # 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:
        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)


    # Placing new order
    api_method = 'fapiPrivatePostOrder'
    params = {
        'symbol': symbol,
        'side': signal.upper(),
        'type': order_type,
        'quantity': quantity,
        'positionSide': position_side,
        'leverage': leverage,
        'price': price,
        'stopPrice': stop_loss_price,
        'takeProfit': take_profit_price
    }
    response = getattr(binance_futures, api_method)(params=params)
    if 'orderId' in response:
        print(f'Order placed: {response}')
    else:
        print(f'Error placing order: {response}')
    time.sleep(1)
    return response
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}")
        time.sleep(1)
But some time it gives me wrong signals , I need after signal_generator give me signal price doesn't go against my signal more than -0.2%