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' quantity = 1 symbol = 'BTC/USDT' 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()

    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" 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', 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 = binance_futures.fetch_ticker(symbol)['askPrice'] # remove rounding here
        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 = binance_futures.fetch_ticker(symbol)['bidPrice'] # remove rounding here
        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:
            try:
                price = round_step_size(price, step_size=step_size)
                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}")
            return
        else:
            take_profit_price = None
            stop_loss_price = None
    else:
        if price is not None:
                try:
                    price = round_step_size(price, step_size=step_size)
                    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}")
                    return
                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/04/2023 07:53:24 BTC/USDT found in the market The signal time is: 2023-06-04 07:53:32 : Traceback (most recent call last): File "c:\Users\Alan.vscode\jew_bot\jew_bot\jew_bot.py", line 237, in order_execution(symbol, signal, MAX_TRADE_QUANTITY_PERCENTAGE, leverage) File "c:\Users\Alan.vscode\jew_bot\jew_bot\jew_bot.py", line 196, 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 being referenced before it is assigned a value. This is happening in the order_execution function when setting the take_profit_price and stop_loss_price variables.

    To fix this, you can move the try/except block for rounding the price variable up to before these variables are set. This way, if there is an error rounding the price, the function will exit early and not try to reference the price variable.

    Here's the modified order_execution function:

    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 = binance_futures.fetch_ticker(symbol)['askPrice'] # remove rounding here
            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 = binance_futures.fetch_ticker(symbol)['bidPrice'] # remove rounding here
            take_profit_percentage = TAKE_PROFIT_PERCENTAGE
            stop_loss_percentage = STOP_LOSS_PERCENTAGE
    
        # Round the price variable
        try:
            price = round_step_size(price, step_size=step_size)
        except Exception as e:
            print(f"Error rounding price: {e}")
            return
    
        # 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':
            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 = 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)
    
        # 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)
    

    Note: I also removed the else block for the take_profit_price and stop_loss_price variables since the variables were being assigned None in that case anyway.

  3. User

    I used your code, but I getting ERROR: The signal time is: 2023-06-04 09:40:03 : Error rounding price: cannot access local variable 'price' where it is not associated with a value

  4. Assistant

    It seems that the price variable is still not being assigned a value correctly in some cases. This can happen if the API request to fetch the ticker price fails or returns None.

    To fix this, you can add a check for None in the order_execution function before attempting to round the price variable. Here's the modified function:

    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 = binance_futures.fetch_ticker(symbol)['askPrice']
            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 = binance_futures.fetch_ticker(symbol)['bidPrice']
            take_profit_percentage = TAKE_PROFIT_PERCENTAGE
            stop_loss_percentage = STOP_LOSS_PERCENTAGE
    
        # Round the price variable
        if price is None:
            print("Price is None")
            return
    
        try:
            price = round_step_size(price, step_size=step_size)
        except Exception as e:
            print(f"Error rounding price: {e}")
            return
    
        # 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':
            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 = 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)
    
        # 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)
    

    With this modification, the function should exit early and print a message if the price is None, rather than trying to round the variable and raising an error.