Skip to content
The Chat Archive
gpt-3.5-turbo-0301· OpenAI 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 json import numpy as np import pytz import datetime as dt import ccxt from decimal import Decimal import requests import hmac import hashlib API_KEY = '' API_SECRET = ''

    client = Client(API_KEY, API_SECRET)

    Set the endpoint and parameters for the request

    url = "https://fapi.binance.com/fapi/v2/account" timestamp = int(time.time() * 1000) recv_window = 5000

    params = { "timestamp": timestamp, "recvWindow": recv_window }

    Sign the message using the Client’s secret key

    message = '&'.join([f"{k}={v}" for k, v in params.items()]) signature = hmac.new(API_SECRET.encode(), message.encode(), hashlib.sha256).hexdigest() params['signature'] = signature leverage = 100

    Send the request using the requests library

    response = requests.get(url, params=params, headers={'X-MBX-APIKEY': API_KEY}) account_info = response.json()

    Get the USDT balance and calculate the max trade size based on the leverage

    try: usdt_balance = next((item for item in account_info['accountBalance'] if item["asset"] == "USDT"), {"free": 0})['free'] except KeyError: usdt_balance = 0 print("Error: Could not retrieve USDT balance from API response.")

    max_trade_size = float(usdt_balance) * leverage

    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)

    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': API_KEY, 'secret': API_SECRET, 'enableRateLimit': True, # enable rate limitation 'options': { 'defaultType': 'future', 'adjustForTimeDifference': True },'future': { 'sideEffectType': 'MARGIN_BUY', # MARGIN_BUY, AUTO_REPAY, etc… } })

    Load the market symbols

    try: markets = binance_futures.load_markets() except ccxt.BaseError as e: print(f'Error fetching markets: {e}') 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 = int(exchange.fetch_time()['timestamp']) 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 time.sleep(1)

    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): # Set default value for response response = {}

    # 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:
            response = binance_futures.fapiPrivatePostOrder(
                data={
                    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
                }
            )
    
    if 'orderId' in response:
        print(f'Closed position: {response}')
    else:
        print(f'Error closing position: {response}')
    time.sleep(1)
    
    # Calculate appropriate order quantity and price based on signal
    opposite_position = None
    quantity = step_size
    position_side = None #initialise 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 = 'TAKE_PROFIT_MARKET'
        ticker = binance_futures.fetch_ticker(symbol)
        price = 0 # default price
        if 'ask' in ticker:
            price = ticker['ask']
        # 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 = 'STOP_MARKET'
        ticker = binance_futures.fetch_ticker(symbol)
        price = 0 # default price
        if 'bid' in ticker:
            price = ticker['bid']
        # 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:
        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)
        # Adjust quantity if opposite position exists
        if opposite_position is not None:
            quantity = round_step_size(abs(float(opposite_position['positionAmt'])), step_size=step_size)
    
    # Place order
    response = binance_futures.fapiPrivatePostOrder(
        data={
            'symbol': symbol,
            'side': signal.upper(),
            'type': order_type,
            'quantity': quantity,
            'positionSide': position_side,
            'leverage': leverage,
            'price': price,
            'stopPrice': stop_loss_price,
            'takeProfit': take_profit_price
        }
    )
    
    if 'orderId' in response:
        print(f'Order placed: {response}')
    else:
        print(f'Error placing order: {response}')
    time.sleep(1)
    return response
    

    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:{signal}") if 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-09 11:56:35, signal:buy Error closing position: {} Traceback (most recent call last): File "c:\Users\Alan.vscode\jew_bot\jew_bot\jew_bot.py", line 279, 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 251, in order_execution response = binance_futures.fapiPrivatePostOrder( ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ TypeError: Entry.init..unbound_method() got an unexpected keyword argument 'data'

  2. Assistant

    It looks like the issue is with the binance_futures.fapiPrivatePostOrder() function call. According to the ccxt documentation, this function takes keyword arguments for each of the parameters, such as symbol, side, type, etc. Instead of passing a data dictionary, you should pass the parameters as keyword arguments directly.

    Here's an updated version of the order_execution() function that should work:

    def order_execution(symbol, signal, step_size, leverage, order_type):
        # Set default value for response
        response = {}
    
        # 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:
                response = 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
                )
    
        if 'orderId' in response:
            print(f'Closed position: {response}')
        else:
            print(f'Error closing position: {response}')
        time.sleep(1)
    
        # Calculate appropriate order quantity and price based on signal
        opposite_position = None
        quantity = step_size
        position_side = None #initialise 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 = 'TAKE_PROFIT_MARKET'
            ticker = binance_futures.fetch_ticker(symbol)
            price = 0 # default price
            if 'ask' in ticker:
                price = ticker['ask']
            # 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 = 'STOP_MARKET'
            ticker = binance_futures.fetch_ticker(symbol)
            price = 0 # default price
            if 'bid' in ticker:
                price = ticker['bid']
            # 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:
            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)
            # Adjust quantity if opposite position exists
            if opposite_position is not None:
                quantity = round_step_size(abs(float(opposite_position['positionAmt'])), step_size=step_size)
    
        # Place order
        response = binance_futures.fapiPrivatePostOrder(
            symbol=symbol,
            side=signal.upper(),
            type=order_type,
            quantity=quantity,
            positionSide=position_side,
            leverage=leverage,
            price=price,
            stopPrice=stop_loss_price,
            takeProfit=take_profit_price
        )
    
        if 'orderId' in response:
            print(f'Order placed: {response}')
        else:
            print(f'Error placing order: {response}')
        time.sleep(1)
        return response
    
  3. User

    How I can print current price of signal ?

  4. Assistant

    You can use the Binance Futures REST API to fetch the current ticker price of your trading pair (e.g. BTC/USDT) and print it.

    Here's an updated order_execution() function that fetches the current ticker price and prints it:

    def order_execution(symbol, signal, step_size, leverage, order_type):
        # Set default value for response
        response = {}
    
        # 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:
                response = 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
                )
    
        if 'orderId' in response:
            print(f'Closed position: {response}')
        else:
            print(f'Error closing position: {response}')
        time.sleep(1)
    
        # Calculate appropriate order quantity and price based on signal
        opposite_position = None
        quantity = step_size
        position_side = None #initialise 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 = 'TAKE_PROFIT_MARKET'
            # Fetch current ticker price
            ticker = binance_futures.fetch_ticker(symbol)
            price = 0 # default price
            if 'ask' in ticker:
                price = ticker['ask']
                print(f'Current ticker price for {symbol}: {price}')
            # 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 = 'STOP_MARKET'
            # Fetch current ticker price
            ticker = binance_futures.fetch_ticker(symbol)
            price = 0 # default price
            if 'bid' in ticker:
                price = ticker['bid']
                print(f'Current ticker price for {symbol}: {