Skip to content
TheChatArchiveThe Chat Archive
gpt-3.5-turbo-0301· openaiHugging Face Suzhen/CodeChat

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_currencies() 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, order_type): # 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
    position_side = None #initialze 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 = FUTURE_ORDER_TYPE_TAKE_PROFIT_MARKET
        ticker = binance_futures.fetch_ticker(symbol)
        price = 0 # default price
        if 'askPrice' in ticker:
            price = ticker['askPrice']
            # 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 = FUTURE_ORDER_TYPE_STOP_MARKET
        ticker = binance_futures.fetch_ticker(symbol)
        price = 0 # default price
        if 'askPrice' in ticker:
            price = ticker['askPrice']
            # 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:
            try:
                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)
            except Exception as e:
                print(f"Error rounding price: {e}")
    
    # Reduce quantity if opposite position exists
    if opposite_position is not None:
        if abs(opposite_position['positionAmt']) < quantity:
            quantity = abs(opposite_position['positionAmt'])
    
    # Update position_side based on opposite_position and current_position
    if opposite_position is not None:
        position_side = opposite_position['positionSide']
    elif current_position is not None:
        position_side = current_position['positionSide']
    
    # Place order
    order_params = {
        "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": leverage
    }
    
    try:
        order_params['symbol'] = symbol
        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)
        return
    

    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, order_type) time.sleep(0.1) But I getting ERROR: BTC/USDT found in the market The signal time is: 2023-06-05 19:51:31 : Traceback (most recent call last): File "c:\Users\Alan.vscode\jew_bot\jew_bot\jew_bot.py", line 254, in order_execution(symbol, signal, MAX_TRADE_QUANTITY_PERCENTAGE, leverage, order_type) File "c:\Users\Alan.vscode\jew_bot\jew_bot\jew_bot.py", line 241, in order_execution response = binance_futures.fapiPrivatePostOrder(**order_params) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ TypeError: Entry.init..unbound_method() got an unexpected keyword argument 'side'

  2. Assistant

    It looks like there is an issue with the function order_execution() where the argument side is not recognized. This could be because the binance_futures.fapiPrivatePostOrder() method does not have a side argument.

    Looking at the Binance API documentation, it seems that the side parameter should be replaced with sideEffectType and set to 'MARGIN_BUY' or 'MARGIN_SELL' for margin orders. So you could replace the line

    "side": "buy" if signal == "buy" else "sell",
    

    with

    "sideEffectType": "MARGIN_BUY" if signal == "buy" else "MARGIN_SELL",
    

    to see if that resolves the issue.

  3. User

    Okay , but I getting ERROR:BTC/USDT found in the market The signal time is: 2023-06-05 20:23:22 : Traceback (most recent call last): File "c:\Users\Alan.vscode\jew_bot\jew_bot\jew_bot.py", line 254, in order_execution(symbol, signal, MAX_TRADE_QUANTITY_PERCENTAGE, leverage, order_type) File "c:\Users\Alan.vscode\jew_bot\jew_bot\jew_bot.py", line 241, in order_execution response = binance_futures.fapiPrivatePostOrder(**order_params) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ TypeError: Entry.init..unbound_method() got an unexpected keyword argument 'sideEffectType'

  4. Assistant

    It looks like there is another issue now that the side parameter has been replaced with sideEffectType.

    The error suggests that sideEffectType is an unexpected keyword argument. This could be because the binance_futures.fapiPrivatePostOrder() method does not have a sideEffectType parameter.

    According to the Binance API documentation, for futures orders, the sideEffectType parameter is not supported and is not required. Instead, you can use the reduceOnly parameter to indicate that an order should only reduce existing positions.

    You could modify the order_params dictionary in the order_execution() function to include reduceOnly=True to ensure the order only reduces existing positions, like so:

    order_params = {
            "sideEffectType": "NO_SIDE_EFFECT", # set a dummy value for unsupported parameter
            "type": order_type,
            "positionSide": position_side,
            "quantity": quantity,
            "price": price,
            "stopPrice": stop_loss_price if signal == "buy" else take_profit_price,
            "reduceOnly": True,
            "newOrderRespType": "RESULT",
            "workingType": "MARK_PRICE",
            "priceProtect": False,
            "leverage": leverage
        }
    

    Also, make sure your API keys and secret are correctly set in the API_KEY and API_SECRET variables and that you have enabled futures trading on your Binance account.

    Finally, make sure that your desired trading symbol 'BTC/USDT' is actually a futures trading pair on Binance and that you have specified the correct market type in the ccxt.binance() configuration. You could try changing the 'defaultType': 'future' parameter to 'defaultType': 'spot' or 'defaultType': 'delivery' to see if that helps.

  5. User

    I used this code, but I still getting ERROR: Traceback (most recent call last): File "c:\Users\Alan.vscode\jew_bot\jew_bot\jew_bot.py", line 254, in order_execution(symbol, signal, MAX_TRADE_QUANTITY_PERCENTAGE, leverage, order_type) File "c:\Users\Alan.vscode\jew_bot\jew_bot\jew_bot.py", line 241, in order_execution response = binance_futures.fapiPrivatePostOrder(**order_params) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ TypeError: Entry.init..unbound_method() got an unexpected keyword argument 'sideEffectType'

  6. Assistant

    I'm sorry to hear that the issue persists. In that case, let's try removing the sideEffectType parameter from the order_params dictionary since it seems that it is still causing issues.

    Instead, you could try setting the reduceOnly parameter to True to ensure that the order only reduces existing positions. You could modify the order_params dictionary in the order_execution() function to include reduceOnly=True and remove the sideEffectType parameter, like so:

    order_params = {
            "type": order_type,
            "positionSide": position_side,
            "quantity": quantity,
            "price": price,
            "stopPrice": stop_loss_price if signal == "buy" else take_profit_price,
            "reduceOnly": True,
            "newOrderRespType": "RESULT",
            "workingType": "MARK_PRICE",
            "priceProtect": False,
            "leverage": leverage
        }
    

    Also, make sure that your API keys and secrets have the correct permissions enabled for futures trading, and that your Binance account has enough funds to execute the trades.

    If the issue still persists, please let me know, and we can try other approaches.

  7. User

    Apsolutly same ERROR

  8. Assistant

    I'm sorry to hear that the issue still persists.

    One possible explanation for this error is that the binance_futures.fapiPrivatePostOrder() method from the ccxt library is not compatible with the Binance Futures API.

    Instead of using the ccxt library, you could try using the Binance Futures API directly by making a request to the API using the requests library. Here is an example of how you could modify the order_execution() function to use the Binance Futures API directly:

    def order_execution(symbol, signal, step_size, leverage, order_type):
        # 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:
                    url = "https://fapi.binance.com/fapi/v1/order"
                    params = {
                        "symbol": symbol,
                        "positionSide": "SELL" if current_position["positionSide"] == "LONG" else "BUY",
                        "type": "MARKET",
                        "quantity": abs(float(current_position["positionAmt"])),
                        "positionSide": current_position["positionSide"],
                        "reduceOnly": "true",
                        "timeInForce": "GTC",
                        "recvWindow": 10000, # set a reasonable value here
                        "timestamp": int(time.time() * 1000)
                    }
                    sign = hmac.new(API_SECRET.encode(), urlencode(params).encode(), hashlib.sha256).hexdigest()
                    headers = {
                        "X-MBX-APIKEY": API_KEY
                    }
                    params["signature"] = sign
                    response = requests.post(url, params=params, headers=headers)
                    if response.status_code == 200:
                        print(f"Position closed successfully: {response.json()}")
                    else:
                        print(f"Error closing position: {response.json()}")
    
        # Calculate appropriate order quantity and price based on signal
        opposite_position = None
        quantity = step_size
        position_side = None #initialze 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 = FUTURE_ORDER_TYPE_TAKE_PROFIT_MARKET
            ticker = binance_futures.fetch_ticker(symbol)
            price = 0 # default price
            if 'askPrice' in ticker:
                price = ticker['askPrice']
                # perform rounding and other operations on price
            else:
                # handle the case where the key is missing (e.g. raise an exception, skip this signal,
    

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.