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

I used this code: import time from binance.client import Client from binance.enums…

  1. User

    I used this 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 import ntplib import os import ta API_KEY = ''

    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

    def sync_time(): ntp_client = ntplib.NTPClient() response = ntp_client.request('pool.ntp.org', version=3) now = time.time() offset = response.offset new_time = now + offset # Set the system clock to the new time os.system(f'sudo date -s @{int(new_time)}') print(f'New time: {dt.datetime.now()}')

    recv_window = 10000 params = { "timestamp": timestamp, "recvWindow": recv_window } 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): return exchange.fetch_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' } 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 df = get_klines(symbol, '1m', 44640)

    Define function to generate trading signals

    def signal_generator(df): open = df.Open.iloc[-1] close = df.Close.iloc[-1] previous_open = df.Open.iloc[-2] previous_close = df.Close.iloc[-2] # Calculate EMA indicator ema = ta.trend.EMAIndicator(df['Close'], window=10)

    # Calculate MA indicator
    ma = ta.trend.SMAIndicator(df['Close'], window=20)
    
    # Calculate EMA indicator
    ema_value = ema.ema_indicator()[-1] #get the EMA indicator value for the last value in the DataFrame
    ma_value = ma.sma_indicator()[-1] #get the MA indicator value for the last value in the DataFrame
    
    #Bearish pattern with EMA and MA indicators
    if (open>close and
    previous_open<previous_close and
    close<previous_open and
    open>=previous_close and
    close<ema_value and close<ma_value):
        return 'sell'
    
    #Bullish pattern with EMA and MA indicators
    elif (open<close and
    previous_open>previous_close and
    close>previous_open and
    open<=previous_close and
    close>ema_value and close>ma_value):
        return 'buy'
    
    #No clear pattern with EMA and MA indicators
    else:
        return ''
    

    df = get_klines(symbol, '1m', 44640)

    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)
    
    
    # Placing new order
    api_method = 'fapiPrivatePostOrder'
    params = {
        '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
    }
    response = getattr(binance_futures, api_method)(params=params)
    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}") time.sleep(1) But some time it gives me wrong signals , I need after signal_generator give me signal price doesn't go against my signal more than -0.2%

  2. Assistant

    To implement a check that ensures the price doesn't go against the generated signal by more than -0.2%, you can modify the order_execution() function as follows:

    1. After calculating the stop loss price, calculate the maximum allowed price in case the signal is 'buy' by multiplying the stop loss price with (1 + 0.002), which is a 0.2% increase.

    2. Similarly, calculate the minimum allowed price in case the signal is 'sell' by multiplying the stop loss price with (1 - 0.002), which is a 0.2% decrease.

    3. After placing the order, continuously check the price of the symbol and if it goes against the generated signal by more than 0.2%, cancel the order and generate a new signal.

    Here's the modified order_execution() function:

    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
    
            # Calculate the maximum allowed price to ensure the price doesn't go against the generated signal by more than -0.2%
            max_price = round_step_size(stop_loss_price * (1 + 0.002), step_size=step_size)
    
        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
    
            # Calculate the minimum allowed price to ensure the price doesn't go against the generated signal by more than -0.2%
            min_price = round_step_size(stop_loss_price * (1 - 0.002), step_size=step_size)
    
        # 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)
    
        # Placing new order
        api_method = 'fapiPrivatePostOrder'
        params = {
            '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
        }
        response = getattr(binance_futures, api_method)(params=params)
        if 'orderId' in response:
            print(f'Order placed: {response}')
        else:
            print(f'Error placing order: {response}')
        time.sleep(1)
    
        # Check the price continuously after placing the order
        if signal == 'buy':
            while True:
                ticker = binance_futures.fetch_ticker(symbol)
                if 'bid' in ticker:
                    if ticker['bid'] < max_price:
                        # Cancel the order and generate a new signal if price goes against the generated signal by more than -0.2%
                        cancel_order = binance_futures.fapiPrivateDeleteOrder(params={'symbol': symbol, 'orderId': response['orderId']})
                        print('Order cancelled due to price movement')
                        order_execution(symbol, signal_generator(df), step_size, leverage, order_type)
                        break
                time.sleep(1)
    
        elif signal == 'sell':
            while True:
                ticker = binance_futures.fetch_ticker(symbol)
                if 'ask' in ticker:
                    if ticker['ask'] > min_price:
                        # Cancel the order and generate a new signal if price goes against the generated signal by more than -0.2%
                        cancel_order = binance_futures.fapiPrivateDeleteOrder(params={'symbol': symbol, 'orderId': response['orderId']})
                        print('Order cancelled due to price movement')
                        order_execution(symbol, signal_generator(df), step_size, leverage, order_type)
                        break
                time.sleep(1)
    
        return response
    
  3. User

    Thats okay, but what I need to change in my signal_generator code so that give me right singals to buy or sell ?

  4. Assistant

    To improve the signal generation in your code, you can try the following modifications:

    1. In the bearish pattern condition of your signal_generator() function, check if the current close price is below both the EMA indicator and the MA indicator, rather than just one of them. This can increase the confidence of the bearish signal.

    2. Similarly, in the bullish pattern condition, check if the current close price is above both the EMA indicator and the MA indicator, rather than just one of them.

    3. Use a longer lookback

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