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

    usdt_balance = next((item for item in account_info[‘assets’] if item[“asset”] == “USDT”), {“balance”: 0}) max_trade_size = float(usdt_balance.get(“balance”, 0)) * 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… } })

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

    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 = exchange.fetch_currencies() return server_time[‘timestamp’]

    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 (openprevious_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 #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 ‘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 = ‘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 stop market order

    if order_type == ‘STOP_MARKET’: try: response = binance_futures.fapiPrivatePostOrder( symbol=symbol, side=‘BUY’ if signal == ‘buy’ else ‘SELL’, type=‘STOP_MARKET’, quantity=quantity, stopPrice=stop_loss_price, reduceOnly=True ) print(f"Order details: {response}”) except BinanceAPIException as e: print(f"Error in order_execution: {e}“) time.sleep(1) return

    Place market or take profit order

    elif order_type == ‘market’: try: response = binance_futures.create_order( symbol=symbol, type=order_type, side=‘BUY’ if signal == ‘buy’ else ‘SELL’, amount=quantity, price=price ) 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}") if signal: order_execution(symbol, signal, MAX_TRADE_QUANTITY_PERCENTAGE, leverage, order_type) time.sleep(0.1) But I getting ERROR: The signal time is: 2023-06-08 10:54:02 :sell Traceback (most recent call last): File “c:\Users\Alan.vscode\jew_bot\jew_bot\jew_bot.py”, line 295, 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 258, in order_execution response = binance_futures.fapiPrivatePostOrder( ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ TypeError: Entry.init..unbound_method() got an unexpected keyword argument ‘symbol’

  2. Assistant

    The issue in the code might be due to the wrong method called with ccxt binance. You are using fapiPrivatePostOrder which is the method for making orders for the binance futures API and requires different parameters including the symbol as an argument. For calling the method on the spot exchange, we have to replace it with a create_order method and provide the other necessary parameters like symbol, order type, side, amount, and price. You can replace the following code block:

    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
        )
    

    With the following code block to create the order on the spot exchange:

    binance_futures.create_order(
         symbol=symbol,
         side='SELL' if current_position["positionSide"] == "LONG" else 'BUY', 
         type='MARKET',
         quantity=abs(float(current_position["positionAmt"])),
         params = {'closePosition': True}
        )
    

    After replacing the code block for the same functions, the code should work fine without any issues.

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