Skip to content
TheChatArchiveThe Chat Archive
gpt-3.5-turbo-0301· OpenAIAi2 WildChat-4.8M (AI2)

I used your code: import time from binance.client import Client from binance.enums…

  1. User

    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 requests import json import numpy as np import pytz import datetime as dt import ccxt

    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)

    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 = 100 max_trade_quantity_percentage = 1 binance_futures = ccxt.binance({ ‘apiKey’: ‘’, ‘secret’: ‘’, ‘enableRateLimit’: True, # enable rate limitation ‘options’: { ‘defaultType’: ‘future’, ‘adjustForTimeDifference’: True } })

    binance_futures = ccxt.binance({ ‘apiKey’: API_KEY, ‘secret’: API_SECRET, ‘enableRateLimit’: True, # enable rate limitation ‘options’: { ‘defaultType’: ‘future’, ‘adjustForTimeDifference’: True } })

    Load the market symbols

    markets = binance_futures.load_markets()

    symbol = ‘BTC/USDT’ 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_time() return server_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

    def get_klines(symbol, interval, lookback): url = “https://fapi.binance.com/fapi/v1/klines” start_time = (dt.datetime.now() - dt.timedelta(minutes=lookback)) end_time = dt.datetime.now() 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 (openprevious_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):

    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 if signal == ‘buy’: position_side = ‘BOTH’ opposite_position = current_position if current_position and current_position[‘positionSide’] == ‘SHORT’ else None order_type = FUTURE_ORDER_TYPE_TAKE_PROFIT_MARKET price = round_step_size(binance_futures.fetch_ticker(symbol)[‘askPrice’], step_size=step_size) 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 = FUTURE_ORDER_TYPE_STOP_MARKET price = round_step_size(binance_futures.fetch_ticker(symbol)[‘bidPrice’], step_size=step_size) take_profit_percentage = TAKE_PROFIT_PERCENTAGE stop_loss_percentage = STOP_LOSS_PERCENTAGE

    Reduce quantity if opposite position exists

    if opposite_position is not None: if abs(opposite_position[‘positionAmt’]) < quantity: quantity = abs(opposite_position[‘positionAmt’])

    Set take profit and stop loss prices

    if signal == ‘buy’: if price is not None: 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) else: take_profit_price = None stop_loss_price = None else: if price is not None: 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) else: take_profit_price = None stop_loss_price = None

    Place order

    order_params = { “symbol”: symbol, “side”: “BUY” if signal == “buy” else “SELL”, “type”: order_type, “positionSide”: position_side, “quantity”: quantity, “price”: price, “stopPrice”: stop_loss_price if signal == “buy” else take_profit_price, “reduceOnly”: False, “newOrderRespType”: “RESULT”, “workingType”: “MARK_PRICE”, “priceProtect”: False, “leverage”: 125 }

    try: response = binance_futures.fapiPrivatePostOrder(**order_params) print(f"Order details: {response}”) except BinanceAPIException as e: print(f"Error in order_execution: {e}“) time.sleep(1) 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}”) order_execution(symbol, signal, MAX_TRADE_QUANTITY_PERCENTAGE, leverage) time.sleep(0.1) But I getting ERROR: BTC/USDT found in the market Error in get_klines: 400 Client Error: Bad Request for url: https://fapi.binance.com/fapi/v1/klines?symbol=BTC/USDT&interval=1m&startTime=2023-05-03 16:20:29.451489&endTime=2023-06-03 16:20:29.451489 Error in get_klines: 400 Client Error: Bad Request for url: https://fapi.binance.com/fapi/v1/klines?symbol=BTC/USDT&interval=1m&startTime=2023-05-03 16:20:30.506275&endTime=2023-06-03 16:20:30.506275 Error in get_klines: 400 Client Error: Bad Request for url: https://fapi.binance.com/fapi/v1/klines?symbol=BTC/USDT&interval=1m&startTime=2023-05-03 16:20:31.565857&endTime=2023-06-03 16:20:31.565857 The signal time is: 2023-06-03 16:20:32 : Traceback (most recent call last): File “c:\Users\Alan.vscode\jew_bot\jew_bot\jew_bot.py”, line 226, in order_execution(symbol, signal, MAX_TRADE_QUANTITY_PERCENTAGE, leverage) File “c:\Users\Alan.vscode\jew_bot\jew_bot\jew_bot.py”, line 190, in order_execution if price is not None: ^^^^^ UnboundLocalError: cannot access local variable ‘price’ where it is not associated with a value

  2. Assistant

    It seems like there is an issue with the API request to Binance. The error message indicates that the server returned a Bad Request error. This could be due to an invalid symbol or an incorrect time range specified in the query parameters.

    You can try the following steps to resolve the issue:

    1. Check if the symbol 'BTCUSDT' is valid in the Binance Futures market by running:
    markets = binance_futures.load_markets()
    if 'BTCUSDT' in markets:
        print("BTCUSDT found in the market")
    else:
        print("BTCUSDT not found in the market")
    

    If the symbol is not found, try using a different symbol that is available in the Binance Futures market.

    1. Check the time range used in the get_klines() function. It seems like the start time is set to a future date (May/June 2023), which could be causing the Bad Request error. You can try using a more recent time range, for example:
    start_time = (dt.datetime.now() - dt.timedelta(hours=24)) # get data for the last 24 hours
    end_time = dt.datetime.now()
    
    1. Make sure that you have valid API keys and that they are correctly provided in the code. You can check your API keys in the Binance account dashboard and update the code with the correct keys.

    Once you have resolved the API request issue, the UnboundLocalError when accessing the price variable should also be resolved.

  3. User

    You mean , I need to set look back to 24 hours ?

  4. Assistant

    Yes, you can set the lookback period to 24 hours if you want to get data for the last day. You can modify the get_klines() function to use a time range for the last 24 hours as follows:

    def get_klines(symbol, interval, lookback):
        url = "https://fapi.binance.com/fapi/v1/klines"
        end_time = int(time.time() * 1000)
        start_time = end_time - lookback
        query_params = f"?symbol={symbol}&interval={interval}&startTime={start_time}&endTime={end_time}"
        ...
    

    Then you can call the function with a lookback period of 24 hours:

    df = get_klines(symbol, '1m', 86400000) # 24 hours in milliseconds
    
  5. User

    But I seted it to 1 month

  6. Assistant

    I see. In that case, you can adjust the start time and end time accordingly to get data for the desired time range. For example, if you want to get data for the last month, you can modify the get_klines() function as follows:

    def get_klines(symbol, interval, lookback):
        url = "https://fapi.binance.com/fapi/v1/klines"
        end_time = int(time.time() * 1000)
        start_time = end_time - lookback
        query_params = f"?symbol={symbol}&interval={interval}&startTime={start_time}&endTime={end_time}"
        ...
    

    Then you can call the function with a lookback period of 1 month:

    lookback = 2592000000 # 1 month in milliseconds (30 days x 24 hours x 60 minutes x 60 seconds x 1000)
    df = get_klines(symbol, '1m', lookback)
    

    Note that Binance limits the amount of data that can be retrieved in a single request, so you may need to split the time range into multiple requests if you want to get data for a longer period.

  7. User

    But what wrong in my code ?

  8. Assistant

    Based on the error message you provided, there seem to be two issues with your code:

    1. The symbol BTC/USDT is used instead of BTCUSDT. Binance uses the symbol BTCUSDT for their futures market, so you should update any references to BTC/USDT to BTCUSDT in your code.

    2. The time range used in the get_klines() function is set to a future date, which is causing the request to fail with a Bad Request error. You need to update the start_time and end_time variables in the function to use a valid time range. You can update them to get data for the last month as shown above.

    Once you have made these changes, your code should be able to retrieve data from the Binance API without any errors.