Como o ChatGPT escreveu todo o código Python para o Binance Crypto Trading Bot

Comecei com uma pergunta básica:
Escreva um script Python que use a API da Binance para negociar BTCUSDT.

E aqui está a resposta do ChatGPT:

Para escrever um script Python que usa a API da Binance para negociar BTCUSDT, primeiro você precisa instalar a biblioteca da Binance. Você pode fazer isso executando o seguinte comando pip:

pip install binance

Depois que a biblioteca da Binance estiver instalada, você pode usar o seguinte código para negociar BTCUSDT:

from binance.client import Client

# Replace with your Binance API key and secret
api_key = '<your-api-key>'
api_secret = '<your-api-secret>'

# Initialize the Binance client
client = Client(api_key, api_secret)

# Place a market buy order for 1 BTC of BTCUSDT
order = client.order_market_buy(
    symbol='BTCUSDT',
    quantity=1
)

# Print the order ID
print(order['id'])Pyh

Este código colocará uma ordem de compra no mercado para 1 BTC de BTCUSDT. Você pode ajustar o parâmetro quantity para negociar uma quantidade diferente de BTC.

Nada mal hein?

Mas se você trabalhou com a API de negociação da Binance, provavelmente encontrou um problema com o tamanho mínimo do pedido. Então vamos pedir ao ChatGPT para cuidar disso também.

Pergunta:
Você pode validar se o valor da quantidade é maior que o valor mínimo solicitado pela Binance?

Para validar se o valor da quantidade é maior que o valor mínimo exigido pela Binance, você pode usar o método client.get_min_notional(). Este método retorna o valor nocional mínimo permitido para uma negociação em um ativo específico. Você pode usar este método para verificar o valor nocional mínimo para BTCUSDT e garantir que a quantidade que você está tentando negociar seja maior ou igual a esse valor mínimo.

Aqui está um exemplo de como você pode usar o método client.get_min_notional() para validar o valor da quantidade em seu script Python:

from binance.client import Client

# Replace with your Binance API key and secret
api_key = '<your-api-key>'
api_secret = '<your-api-secret>'

# Initialize the Binance client
client = Client(api_key, api_secret)
# Get the minimum notional value for BTCUSDT
min_notional = client.get_min_notional(symbol='BTCUSDT')
# Place a market buy order for 1 BTC of BTCUSDT if the quantity is greater than or equal to the minimum notional value
quantity = 1
if quantity >= min_notional:
    order = client.order_market_buy(
        symbol='BTCUSDT',
        quantity=quantity
    )
    # Print the order ID
    print(order['id'])
else:
    print('Quantity must be greater than or equal to the minimum notional value of {} BTCUSDT'.format(min_notional))

Neste código, primeiro usamos o client.get_min_notional() para obter o valor nocional mínimo para BTCUSDT. Em seguida, verificamos se a quantity é maior ou igual a esse valor mínimo e, se for, colocamos uma ordem de compra no mercado para a quantidade especificada de BTCUSDT. Se quantity for menor que o valor nocional mínimo, imprimimos uma mensagem de erro.

Isso já parece bem legal, mas eu gostaria que esse código fosse empacotado como uma função, para que eu pudesse reutilizá-lo.

Pergunta:
Você pode fazer funcionar este código e usar “symbol”, “quantity” como variável de entrada e retornar order_id como variável de saída, e use ap_key e api_secret declarados globalmente?

Aqui está um exemplo de como você pode transformar o código da resposta anterior em uma função que recebe symbol e quantity como variáveis ​​de entrada e usa os valores globais nas variáveis api_key e api_secret:

from binance.client import Client

# Replace with your Binance API key and secret
api_key = '<your-api-key>'
api_secret = '<your-api-secret>'

# Initialize the Binance client
client = Client(api_key, api_secret)

def buy_order(symbol, quantity):
    # Get the minimum notional value for the specified symbol
    min_notional = client.get_min_notional(symbol=symbol)

    # Place a market buy order for the specified quantity of the symbol if the quantity is greater than or equal to the minimum notional value
    if quantity >= min_notional:
        order = client.order_market_buy(
            symbol=symbol,
            quantity=quantity
        )

        # Return the order ID
        return order['id']
    else:
        print('Quantity must be greater than or equal to the minimum notional value of {} {}'.format(min_notional, symbol))
        return None

# Trade 1 BTC of BTCUSDT
order_id = buy_order('BTCUSDT', 1)
print(order_id)

Neste código, primeiro definimos uma função chamada buy_order() que recebe symbol e quantity como argumentos de entrada. Dentro da função, usamos o client.get_min_notional() para obter o valor nocional mínimo para o especificado symbol e, em seguida, verificamos se o quantity é maior ou igual a esse valor mínimo. Se for, colocamos uma ordem de compra no mercado para o especificado quantity de symbol. Se quantity for menor que o valor nocional mínimo, imprimimos uma mensagem de erro.

Você pode então chamar a buy_order() para negociar uma quantidade específica de BTCUSDT ou qualquer outro símbolo compatível com a API da Binance.

Ok, isso parece bastante decente para mim. O script executará uma ordem de compra no mercado na Binance e fornecerá o ID da ordem como uma variável de saída. Mas também gostaria de verificar o status do meu pedido.

Descrição:
Adicione uma função que verifica o status do pedido de compra.

Para adicionar uma função que verifica o status de um pedido de compra, você pode usar o método client.get_order() da biblioteca Binance. Esse método usa symbol e orderId como argumentos de entrada e retorna os detalhes do pedido com o especificado orderId para o especificado symbol.

Aqui está um exemplo de como você pode adicionar uma função de chamada check_order_status() que usa o método client.get_order() para verificar o status de um pedido de compra:

def check_order_status(symbol, order_id):
    # Get the order details for the specified symbol and order ID
    order = client.get_order(
        symbol=symbol,
        orderId=order_id
    )

    # Print the order status
    print('Order status: {}'.format(order['status']))

# Trade 1 BTC of BTCUSDT
order_id = buy_order('BTCUSDT', 1)

# Check the status of the order
check_order_status('BTCUSDT', order_id)

Neste código, adicionamos uma função chamada check_order_status() que recebe symbol e order_id como argumentos de entrada. Dentro da função, utilizamos o client.get_order() para obter os detalhes do pedido com o especificado order_id para o especificado symbol. Em seguida, imprimimos o status do order, que contém o status do pedido.

Você pode então chamar a função check_order_status() para verificar o status de um pedido de compra que foi feito usando a função buy_order().

Isso parece elegante para mim. Agora preciso de uma função que também possa colocar uma ordem de venda no mercado. E meu próximo prompt será um pouco mais complexo. Vamos ver como o OpenGPT pode lidar com isso…

Pergunta:
Escreva uma função que coloque uma ordem de venda também, valide a quantidade de venda com o tamanho do bloco necessário da Binance, reduza a quantidade de venda para o tamanho do bloco necessário, se necessário.

Para escrever uma função que coloca uma ordem de venda, você pode usar o método client.order_market_sell() da biblioteca Binance. Esse método usa symbol, quantity e outros parâmetros como argumentos de entrada e coloca uma ordem de venda no mercado para o especificado quantity de symbol.

Para validar a quantidade de venda e reduzi-la ao tamanho do pedaço necessário, se necessário, você pode usar o método client.get_symbol_info(). Este método retorna informações sobre um símbolo, incluindo o campo stepSize, que contém a quantidade mínima que pode ser negociada para o símbolo. Você pode usar esse stepSize para calcular o tamanho do bloco necessário e ajustar o valor quantity da ordem de venda, se necessário.

Aqui está um exemplo de como você pode escrever uma função chamada sell_order() que coloca uma ordem de venda no mercado para um especificado quantity de symbol, e valida e ajusta quantity se necessário:

def sell_order(symbol, quantity):
    # Get the symbol information
    symbol_info = client.get_symbol_info(symbol=symbol)

    # Calculate the required chunk size
    chunk_size = symbol_info['filters'][2]['stepSize']

    # Adjust the quantity to the required chunk size if necessary
    if quantity % chunk_size != 0:
        quantity = int(quantity / chunk_size) * chunk_size

    # Place a market sell order for the specified quantity of the symbol
    order = client.order_market_sell(
        symbol=symbol,
        quantity=quantity
    )

    # Return the order ID
    return order['id']

# Sell 1 BTC of BTCUSDT
order_id = sell_order('BTCUSDT', 1)
print(order_id)

Neste código, definimos uma função chamada sell_order() que recebe symbol e quantity como argumentos de entrada. Dentro da função, usamos o client.get_symbol_info() para obter as informações do símbolo e, em seguida, calculamos o tamanho do bloco necessário usando o stepSize. Se quantity não for um múltiplo do tamanho do bloco, ajustamos o quantity para o tamanho do bloco necessário. Em seguida, usamos o client.order_market_sell() para colocar uma ordem de venda no mercado para o ajuste quantity de symbol, e retornamos o ID da ordem.

Você pode então chamar a função sell_order() para colocar uma ordem de venda no mercado para um especificado quantity de symbol, e a função irá validar e ajustar quantity se necessário antes de colocar a ordem.

Honestamente, estou super impressionado! Eu não poderia escrever melhor. Bom trabalho OpenGPT!
Então, temos 3 funções até agora:

• buy_order()
• sell_order()
• check_order_status()

Estas são as funções do motor para o bot de negociação, mas para torná-lo totalmente autônomo, precisamos de alguns indicadores de negociação que possam ser usados ​​como gatilho para atividades de compra e venda.

Pergunta:
Vamos adicionar uma função que lê os dados das velas da Binance, faça período, intervalo como entrada, e a saída é um dataframe panda com valores de fechamento, abertura, alto, baixo e volume em formato numérico.

Para ler os dados das velas da Binance e retorná-los como um Pandas DataFrame, você precisará instalar a biblioteca pandas. Você pode fazer isso executando o seguinte comando pip:

pip install pandas

Depois que a biblioteca pandas estiver instalada, você pode usar o seguinte código para ler os dados das velas da Binance e retorná-los como um Pandas DataFrame:

from binance.client import Client
import pandas as pd

# Replace with your Binance API key and secret
api_key = '<your-api-key>'
api_secret = '<your-api-secret>'

# Initialize the Binance client
client = Client(api_key, api_secret)

def get_candles(symbol, period, interval):
    # Get the candles data for the specified symbol, period, and interval
    candles = client.get_klines(
        symbol=symbol,
        interval=interval,
        limit=period
    )

    # Create a Pandas DataFrame from the candles data
    df = pd.DataFrame(candles, columns=[
        'open_time',
        'open',
        'high',
        'low',
        'close',
        'volume',
        'close_time',
        'quote_asset_volume',
        'number_of_trades',
        'taker_buy_base_asset_volume',
        'taker_buy_quote_asset_volume',
        'ignore'
    ])

    # Convert the column values to numerical values
    df = df.apply(pd.to_numeric)

    # Return the Pandas DataFrame
    return df

# Get the candles data for BTCUSDT for the past 1 hour with a 1 minute interval
df = get_candles('BTCUSDT', 60, '1m')
print(df)

Neste código, definimos uma função chamada get_candles() que recebe symbol, period e interval como argumentos de entrada. Dentro da função, usamos o método client.get_klines() para obter os dados das velas para os valores symbol, period e interval. Em seguida, criamos um Pandas DataFrame a partir dos dados das velas e convertemos os valores da coluna em valores numéricos usando o método pd.to_numeric(). Por fim, retornamos o DataFrame do Pandas.

Você pode então chamar a função get_candles() para obter os dados das velas para um específico symbol, period e interval, e a função retornará os dados das velas como um Pandas DataFrame. Você pode usar o DataFrame retornado para executar várias operações nos dados das velas, como calcular médias móveis, plotar os dados e muito mais.

Isso funcionou muito bem também, parabéns pelo ChatGPT!
Vamos pegar o indicador RSI como uma função, não é?

Pergunta:
Adicione uma função que calcula o RSI com base no dataframe do pandas, torne o comprimento do RSI como variável de entrada e retorne os resultados do RSI como um dataframe

Para calcular o índice de força relativa (RSI) com base em um Pandas DataFrame, você pode usar a função talib.RSI() da biblioteca TA-Lib. Esta biblioteca fornece uma ampla gama de indicadores de análise técnica, incluindo o RSI.

Para instalar a TA-Libbiblioteca, você pode executar o seguinte comando pip:

pip install TA-Lib

Depois que a biblioteca TA-Lib estiver instalada, você pode usar o seguinte código para calcular o RSI para um Pandas DataFrame e retornar os resultados como um novo DataFrame:

import talib

def get_rsi(df, length):
    # Calculate the RSI
    rsi = talib.RSI(df['close'], timeperiod=length)

    # Create a Pandas DataFrame with the RSI values
    rsi_df = pd.DataFrame(rsi, columns=['RSI'])

    # Return the RSI DataFrame
    return rsi_df

# Get the candles data for BTCUSDT for the past 1 hour with a 1 minute interval
df = get_candles('BTCUSDT', 60, '1m')

# Calculate the RSI for the candles data with a length of 14
rsi = get_rsi(df, 14)
print(rsi)

Vamos combinar todas as funções juntas, para termos uma boa visão do que o ChatGPT criou

from binance.client import Client
import pandas as pd
import talib

# Replace with your Binance API key and secret
api_key = '<your-api-key>'
api_secret = '<your-api-secret>'

# Initialize the Binance client
client = Client(api_key, api_secret)

def buy_order(symbol, quantity):
    # Get the minimum notional value for the specified symbol
    min_notional = client.get_min_notional(symbol=symbol)

    # Place a market buy order for the specified quantity of the symbol if the quantity is greater than or equal to the minimum notional value
    if quantity >= min_notional:
        order = client.order_market_buy(
            symbol=symbol,
            quantity=quantity
        )

        # Return the order ID
        return order['id']
    else:
        print('Quantity must be greater than or equal to the minimum notional value of {} {}'.format(min_notional, symbol))
        return None

def sell_order(symbol, quantity):
    # Get the symbol information
    symbol_info = client.get_symbol_info(symbol=symbol)

    # Calculate the required chunk size
    chunk_size = symbol_info['filters'][2]['stepSize']

    # Adjust the quantity to the required chunk size if necessary
    if quantity % chunk_size != 0:
        quantity = int(quantity / chunk_size) * chunk_size

    # Place a market sell order for the specified quantity of the symbol
    order = client.order_market_sell(
        symbol=symbol,
        quantity=quantity
    )

    # Return the order ID
    return order['id']

def check_order_status(symbol, order_id):
    # Get the order details for the specified symbol and order ID
    order = client.get_order(
        symbol=symbol,
        orderId=order_id
    )

    # Print the order status
    print('Order status: {}'.format(order['status']))

def get_candles(symbol, period, interval):
    # Get the candles data for the specified symbol, period, and interval
    candles = client.get_klines(
        symbol=symbol,
        interval=interval,
        limit=period
    )

    # Create a Pandas DataFrame from the candles data
    df = pd.DataFrame(candles, columns=[
        'open_time',
        'open',
        'high',
        'low',
        'close',
        'volume',
        'close_time',
        'quote_asset_volume',
        'number_of_trades',
        'taker_buy_base_asset_volume',
        'taker_buy_quote_asset_volume',
        'ignore'
    ])

    # Convert the column values to numerical values
    df = df.apply(pd.to_numeric)

    # Return the Pandas DataFrame
    return df

def get_rsi(df, length):
    # Calculate the RSI
    rsi = talib.RSI(df['close'], timeperiod=length)

    # Create a Pandas DataFrame with the RSI values
    rsi_df = pd.DataFrame(rsi, columns=['RSI'])

    # Return the RSI DataFrame
    return rsi_df

Então, o que temos até agora?

• buy_order()
• sell_order()
• check_order_status()
• get_candles()
• get_rsi()

Agora precisamos amarrar tudo e ver como o ChatGPT pode lidar com isso.

Pergunta:
escreva um script que execute um buy_order se o RSI aumentar acima de 60, armazene o preço de compra em uma variável e calcule o lucro em relação a ele e execute o pedido de venda se o lucro for maior que 5% ou a perda for maior que 2%.

Para escrever um script que execute uma ordem de compra se o valor do RSI for maior que 60 e, em seguida, armazene o preço de compra em uma variável e calcule o lucro, você pode usar a função buy_order() que definimos anteriormente, junto com as funções get_candles() e get_rsi(). Você pode usar um while loop simples para verificar continuamente o valor do RSI e executar uma ordem de compra se o RSI for maior que 60.

Aqui está um exemplo de como você pode escrever um script que executa uma ordem de compra quando o RSI é maior que 60, calcula o lucro e, em seguida, executa uma ordem de venda se o lucro for maior que 5% ou a perda for maior que 2%:

# Substitua pelo seu símbolo, período e intervalo
symbol = 'BTCUSDT'
period = 60
interval = '1m'

# Obtenha os dados das velas 
df = get_candles(symbol, period, interval)

# Calcule o RSI
rsi_df = get_rsi(df, 14)

# Inicialize o preço de compra
purchase_price = 0

# Verifique continuamente o valor do RSI e execute uma ordem de compra se o RSI for maior que 60 
while True:
    # Obtenha o último valor do RSI
    rsi = rsi_df['RSI'].iloc[-1]

    # Verifique se o RSI é maior que 60 
    if rsi > 60 and purchase_price == 0:
        # Faça uma ordem de compra
        order_id = buy_order(symbol, 1)

        # Obtém os últimos dados das velas 
        df = get_candles(symbol, period, interval)

        # Obtém o preço de fechamento mais recente
        close = df['close'].iloc[-1]

        # Define o preço de compra
        purchase_price = close

        # Imprime o preço de compra 
        print('Purchase price: {}'.format(purchase_price))
    else:
        # Verifica se o preço de compra está definido 
        if purchase_price > 0:
            # Obtém os últimos dados das velas 
            df = get_candles(symbol, period, interval)

            # Obtém o preço de fechamento mais recente
            close = df['close'].iloc[-1]

            # Calcula o lucro
            profit = (close - purchase_price) / purchase_price * 100

            # Verifica se o lucro é maior que 5% ou a perda é maior que 2% 
            if profit > 5 or profit < -2:
                # Coloque uma ordem de venda
                order_id = sell_order(symbol, 1)

                # Redefina o preço de compra
                purchase_price = 0

                # Imprima o lucro 
                print('Profit: {}%'.format(profit))

Neste código, adicionamos o código para calcular o lucro e executar uma ordem de venda se o lucro for maior que 5% ou a perda for maior que 2%. Dentro do while loop, verificamos se o valor do RSI é maior que 60, e se for, executamos uma ordem de compra e configuramos a variável purchase_price para o preço de fechamento atual. Se o valor do RSI não for maior que 60, verificamos se a variável purchase_price está definida.

Não é uma ferramenta incrível? Tenho a certeza que o ChatGPT vai mudar a forma como trabalhamos e será a minha ferramenta preferida!

Fonte: https://medium.com/@neonforge/how-chatgpt-wrote-an-entire-python-code-for-binance-crypto-trading-bot-8e971f89b190