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 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… } })

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

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

    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: 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', 44640) # 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 in order exceution, ERROR:The signal time is: 2023-06-09 00:13:02, signal:buy Traceback (most recent call last): File "c:\Users\Alan.vscode\jew_bot\jew_bot\jew_bot.py", line 270, 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 181, in order_execution if 'orderId' in response: ^^^^^^^^^ UnboundLocalError: cannot access local variable 'response' where it is not associated with a value

  2. Assistant

    The issue seems to be with the variable response in the order_execution function. If there is an error in the code block that sets response, then response will not be defined and calling it in the if statement will result in an error. To fix this, you can add a default value for response before the code block that sets its value. For example:

    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
                    }
                )
    
        # ...
    

    This way, response will always have a value even if an error occurs in the code block that sets its value.

  3. User

    Can you give me fully right code

  4. Assistant

    Certainly! Here's the updated order_execution function with the default value set for response:

    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
    

    Note that I only provided the updated order_execution function. You'll need to add this to your existing code in the appropriate spot and test to make sure everything works as expected.

  5. User

    I used your code, but I getting ERROR: BTC/USDT found in the market The signal time is: 2023-06-09 00:34:19, signal:buy Error closing position: {} Traceback (most recent call last): File "c:\Users\Alan.vscode\jew_bot\jew_bot\jew_bot.py", line 273, 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 245, in order_execution response = binance_futures.fapiPrivatePostOrder( ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ TypeError: Entry.init..unbound_method() got an unexpected keyword argument 'data'

  6. Assistant

    The issue now is that the call to fapiPrivatePostOrder is failing because the keyword argument data is not recognized. It looks like this is because ccxt.binance uses different method names for private and public API calls, and the data key is used in the public API but not the private API.

    To fix this, you can replace data with params in the call to fapiPrivatePostOrder, since the private API expects the parameters to be passed as a dictionary using params instead of data. Here's the updated function:

    def order_execution(symbol, signal, step_size, leverage, order_type):
        # Set default value for response
        response = {}
    
        # Close any
    

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