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

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

  1. User

    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 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' 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', 89280)

    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', 89280) 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', 89280) # 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: 06/03/2023 17:11:10 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-04-02%2017:11:15.083193&endTime=2023-06-03%2017:11:15.083193 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-04-02%2017:11:16.135432&endTime=2023-06-03%2017:11:16.135432 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-04-02%2017:11:17.187952&endTime=2023-06-03%2017:11:17.187952 The signal time is: 2023-06-03 17:11:18 : Traceback (most recent call last): File "c:\Users\Alan.vscode\jew_bot\jew_bot\jew_bot.py", line 225, in order_execution(symbol, signal, MAX_TRADE_QUANTITY_PERCENTAGE, leverage) File "c:\Users\Alan.vscode\jew_bot\jew_bot\jew_bot.py", line 189, in order_execution if price is not None: ^^^^^ UnboundLocalError: cannot access local variable 'price' where it is not associated with a value

  2. Assistant

    The error is occurring because the price variable is only defined under certain conditions in the order_execution function. If those conditions are not met, the variable is not defined and an error occurs when attempting to access it later. To fix this, you should define price before the conditions using a default value of None, and then update it within each condition if that condition is met. For example:

    def order_execution(symbol, signal, step_size, leverage):
        # Initialize price
        price = None
        ...
        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)
            ...
        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)
            ...
        ...
    

    This ensures that price is always defined and avoids the error.

  3. User

    Give me full code

  4. Assistant

    Sure, here's the updated code with the fix:

    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'
    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', 89280)
    
    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', 89280)
    def order_execution(symbol, signal, step_size, leverage):
        # Initialize price
        price = None
        
        # 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)