I used this code: import time
from binance.client import Client
from binance.enums import *
from binance.exceptions import BinanceAPIException
import pandas as pd
import requests
import json
import numpy as np
import pytz
import datetime as dt

date = dt.datetime.now().strftime("%m/%d/%Y %H:%M:%S")
print(date)

url = "https://api.binance.com/api/v1/time"
t = time.time()*1000
r = requests.get(url)
result = json.loads(r.content)

# API keys and other configuration
API_KEY = ''
API_SECRET = ''

client = Client(API_KEY, API_SECRET)

STOP_LOSS_PERCENTAGE = -50
TAKE_PROFIT_PERCENTAGE = 100
MAX_TRADE_QUANTITY_PERCENTAGE = 100
POSITION_SIDE_SHORT = 'SELL'
POSITION_SIDE_LONG = 'BUY'
symbol = 'BTCUSDT'
quantity = 1
order_type = 'MARKET'
leverage = 125
max_trade_quantity_percentage = 1

client = Client(API_KEY, API_SECRET)

def getminutedata(symbol, interval, lookback):
    klines = client.get_historical_trades(symbol=symbol,interval=interval, limit=lookback, endTime=int(time.time()*1000))
    # Cast tuples to lists
    klines_values = list(klines.values())
    frame = pd.DataFrame(klines_values, columns=['Open time', 'Price', 'Qty', 'QuoteQty', 'Time', 'Buyer Maker', 'Best Match'])
    frame = frame[['Open time', 'Price', 'Qty']]
    frame['Open time'] = pd.to_datetime(frame['Open time'], unit='ms').dt.tz_localize('UTC').dt.tz_convert('Etc/GMT+3')
    frame.set_index('Open time', inplace=True)
    frame.drop(frame.tail(1).index, inplace=True) # Drop the last candle we fetched
    return frame
df = getminutedata('BTCUSDT', '1m', 44640)
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]

    # 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 = getminutedata('BTCUSDT', '1m', 44640)
def order_execution(symbol, signal, max_trade_quantity_percentage, leverage):
    signal = signal_generator(df)
    max_trade_quantity = None
    account_balance = client.futures_account_balance()
    usdt_balance = float([x['balance'] for x in account_balance if x['asset'] == 'USDT'][0])
    max_trade_quantity = usdt_balance * max_trade_quantity_percentage/100

    # Close long position if signal is opposite
    long_position = None
    short_position = None
    positions = client.futures_position_information(symbol=symbol)
    for p in positions:
        if p['positionSide'] == 'LONG':
            long_position = p
        elif p['positionSide'] == 'SHORT':
            short_position = p
        if long_position is not None and short_position is not None:
            print("Multiple positions found. Closing both positions.")
        if long_position is not None:
            client.futures_create_order(
                symbol=symbol,
                side=SIDE_SELL,
                type=ORDER_TYPE_MARKET,
                quantity=long_position['positionAmt'],
                reduceOnly=True
            )
        time.sleep(1)
    if short_position is not None:
        client.futures_create_order(
            symbol=symbol,
            side=SIDE_BUY,
            type=ORDER_TYPE_MARKET,
            quantity=short_position['positionAmt'],
            reduceOnly=True
        )
    time.sleep(1)
    print("Both positions closed.")

    if signal == 'buy':
        position_side = POSITION_SIDE_LONG
        opposite_position = short_position
    elif signal == 'sell':
        position_side = POSITION_SIDE_SHORT
        opposite_position = long_position
    else:
        print("Invalid signal. No order placed.")
        return
    order_quantity = 0
    if opposite_position is not None:
        order_quantity = min(max_trade_quantity, abs(float(opposite_position['positionAmt'])))
    if opposite_position is not None and opposite_position['positionSide'] != position_side:
        print("Opposite position found. Closing position before placing order.")
    client.futures_create_order(
        symbol=symbol,
        side=SIDE_SELL if
            opposite_position['positionSide'] == POSITION_SIDE_LONG
    else
        SIDE_BUY,
        type=ORDER_TYPE_MARKET,
        quantity=order_quantity,
        reduceOnly=True,
        positionSide=opposite_position['positionSide']
    )
    time.sleep(1)

    order = client.futures_create_order(
        symbol=symbol,
        side=SIDE_BUY if signal == 'buy' else SIDE_SELL,
        type=ORDER_TYPE_MARKET,
        quantity=order_quantity,
        reduceOnly=False,
        timeInForce=TIME_IN_FORCE_GTC,
        positionSide=position_side, # add position side parameter
        leverage=leverage
    )
    if order is None:
        print("Order not placed successfully. Skipping setting stop loss and take profit orders.")
        return
    order_id = order['orderId']
    print(f"Placed {signal} order with order ID {order_id} and quantity {order_quantity}")
    time.sleep(1)

    # Set stop loss and take profit orders
    # Get the order details to determine the order price
    order_info = client.futures_get_order(symbol=symbol, orderId=order_id)
    if order_info is None:
        print("Error getting order information. Skipping setting stop loss and take profit orders.")
        return
    order_price = float(order_info['avgPrice'])

    # Set stop loss and take profit orders
    stop_loss_price = order_price * (1 + STOP_LOSS_PERCENTAGE / 100) if signal == 'sell' else order_price * (1 - STOP_LOSS_PERCENTAGE / 100)
    take_profit_price = order_price * (1 + TAKE_PROFIT_PERCENTAGE / 100) if signal == 'buy' else order_price * (1 - TAKE_PROFIT_PERCENTAGE / 100)
    stop_loss_order = client.futures_create_order(
        symbol=symbol,
        side=SIDE_SELL if signal == 'buy' else SIDE_BUY,
        type=ORDER_TYPE_STOP_LOSS,
        quantity=order_quantity,
        stopPrice=stop_loss_price,
        reduceOnly=True,
        timeInForce=TIME_IN_FORCE_GTC,
        positionSide=position_side # add position side parameter
    )
    take_profit_order = client.futures_create_order(
        symbol=symbol,
        side=SIDE_SELL if signal == 'buy' else SIDE_BUY,
        type=ORDER_TYPE_LIMIT,
        quantity=order_quantity,
        price=take_profit_price,
        reduceOnly=True,
        timeInForce=TIME_IN_FORCE_GTC,
        positionSide=position_side # add position side parameter
    )
    # Print order creation confirmation messages
    print(f"Placed stop loss order with stop loss price {stop_loss_price}")
    print(f"Placed take profit order with take profit price {take_profit_price}")
    time.sleep(1)

async def trading_loop():
    while True:
        df = getminutedata('BTCUSDT', '1m', 44640)
        if df is None:
            continue
        signal = signal_generator(df)
        print(f"The signal time is: {dt.datetime.now().strftime('%Y-%m-%d %H:%M:%S')} :{signal}")
        if signal:
            order_execution('BTCUSDT', signal, MAX_TRADE_QUANTITY_PERCENTAGE, leverage)
            time.sleep(1) But I getting ERROR:  File "c:\Users\Alan\.vscode\jew_bot\jew_bot\jew_bot.py", line 49, in <module>
    df = getminutedata('BTCUSDT', '1m', 44640)
         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "c:\Users\Alan\.vscode\jew_bot\jew_bot\jew_bot.py", line 42, in getminutedata
    klines_values = list(klines.values())
                         ^^^^^^^^^^^^^
AttributeError: 'coroutine' object has no attribute 'values'
sys:1: RuntimeWarning: coroutine 'ClientBase._request' was never awaited Please give me right code