Bonjour à tous,

J'aimerais créer un bots pour trade les crypto, n'y connaissant pas grand chose en programmation j'ai décidé de partir sur une base qui me semble adéquate à mon utilisation.
J'ai donc trouvé ce tuto

Voici l'ensemble de mon code:
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
# Tout d'abord, nous importons les bibliothèques et définissons la clé API et la clé secrète.
 
import random
import pandas as pd
import time
import numpy as np
import datetime as dt
import plotly.graph_objects as go
from plotly.subplots import make_subplots
import plotly
import plotly.io as pio
import pandas as pd
import datetime
from futurespy import Client
from binance.client import Client as ClientReal
import talib
 
api_key='****'
api_secret='****'
 
client = Client(api_key, api_secret, testnet=True)
clientreal = ClientReal(api_key, api_secret)
 
 
# Afin de gérer la commande et de vérifier le signal, nous définissons une classe.
    # La fonction get_signal prend les données des 40 dernières minutes de Binance. Nous nous intéressons au cours de clôture, car nous pouvons calculer la moyenne mobile des poids. Qu'avec data['action'] nous savons s'il y a un croisement entre WMA7 et WMA14.
    # Lorsque WMA7>WMA14 la data['action'] est égale à 1 et c'est le signal d'achat.
    # L'inverse lorsque WMA7<WMA14 la data['action'] est égale à -1 et c'est le signal de vente.
 
class Order():
    def __init__(self, DATASET):
        #init
        self.DATASET=DATASET
        self.count_step = 0
        self.INVEST = 0.001
        self.FlagBuy = False
        self.FlagSell = False
        self.trak_profit = [0] 
 
        #general
        self.INIT_BALANCE=float(client.balance()[0]['balance'])
        self.balance=self.INIT_BALANCE
 
        #to track
        self.history_balance=[self.INIT_BALANCE]
 
        self.profit = [0]
        self.comulative_profit = [0]
        self.comulative_accuracy = [0]
        self.correct = 0
        self.wrong = 0
 
    def get_signal(self):
        candles = clientreal.get_klines(symbol=self.DATASET[0], 
                      interval=clientreal.KLINE_INTERVAL_1MINUTE, 
                      limit=40)
        data = pd.DataFrame({'close':np.asarray(candles)[:,4]})
        data['close'] = data['close'].astype(float)
        data['wma7'] = talib.WMA(data['close'], timeperiod=7)
        data['wma14'] = talib.WMA(data['close'], timeperiod=14)
        data['signal'] = np.where(data['wma14'] > data['wma7'], 1, 0)
        data['action'] = data['signal'].diff()
 
        if list(data['action'])[-1]==1:
            self.action=1
        elif list(data['action'])[-1]==-1:
            self.action=-1
        else:
            self.action=0
 
        self.action_open()
 
 
# Nous exécutons l'action appelant la fonction action_open().
    # En plus de l'exécution de la commande, certaines variables permettent de suivre nos performances.
 
    def action_open(self):
        self.start_balance=self.balance
 
        if self.action==1:
            client.new_order(side='BUY',
                                quantity=self.INVEST,
                                symbol=self.DATASET[0],
                                orderType='MARKET')
            self.FlagBuy=True
 
        elif self.action==-1:
            client.new_order(side='SELL',
                                quantity=self.INVEST,
                                symbol=self.DATASET[0],
                                orderType='MARKET')
            self.FlagSell=True
 
        self.balance=float(client.balance()[0]['balance'])
        if (self.balance-self.start_balance)>0:
            self.correct+=1
        else:
            self.wrong+=1
        print('net', self.balance-self.start_balance)    
 
        self.profit.append(self.balance-self.start_balance)
        self.comulative_profit.append(self.comulative_profit[-1]+self.profit[-1])
        self.comulative_accuracy.append(self.correct/(self.corect+self.wronk))
        self.history_balance.append(self.balance)
 
 
# La dernière fonction est de tracer les performances.
 
    def render(self):    
        fig0 = make_subplots(rows=4, cols=1, shared_xaxes=False, vertical_spacing=0.1,
                                    subplot_titles=('Profit', 'Accuracy', 'Comulative Profit', 'Balance'))
        rw_plot=go.Scatter(mode="lines", y=self.profit, name='Profit', line=dict(width=3))
        fig0.add_trace(rw_plot, row=1, col=1) 
 
        rw_plot=go.Scatter(mode="lines", y=self.comulative_accuracy, name='Accuracy', line=dict(width=3))
        fig0.add_trace(rw_plot, row=2, col=1) 
 
        rw_mean_plot=go.Scatter(mode="lines", y=self.comulative_profit, 
                                name='Comulative Profite', line=dict(width=3))
        fig0.add_trace(rw_mean_plot, row=3, col=1) 
 
        bl_plot=go.Scatter(mode="lines", y=self.history_balance, name='Balance', line=dict(width=3))
        fig0.add_trace(bl_plot, row=4, col=1)
 
        fig0=go.Figure(fig0)
        #fig0.write_image(f'{path}/performance.svg')
        plotly.offline.plot(fig0, show_link=False, filename = f' {path}/performance.html', include_plotlyjs="cdn")
 
 
# La classe Order est définie et nous pouvons appeler la classe dans le main.
    # L'ensemble de données indique la crypto-monnaie à échanger. Le chemin indique où stocker le graphique de performance.
    # Le while permet de recevoir le signal toutes les minutes et d'exécuter l'action.
 
if __name__=='__main__':
    DATASET=['BTCUSDT']#, 'ETHUSDT', 'LTCUSDT']
 
    path='/BINANCE/wma_bot/' 
 
    order=Order(DATASET)
    new_history=len(order.profit)
    while True:
        if time.localtime().tm_sec==1:
            order.get_signal()
            print('time', datetime.datetime.now().strftime("%H:%M:%S"))
            print('buy:', order.FlagBuy, 'sell:', order.FlagSell)
            print('balance %', order.balance/order.INIT_BALANCE)
 
        if len(order.profit)>new_history:
            print('render')
            new_history=len(order.profit)
            order.render()
Et voici les erreurs que je n'arrive pas à résoudre:

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
Admin@DESKTOP-FBLTEP3 MINGW64 ~/Desktop/aldini
n/Desktop/aldini/Aldini.pyocal/Programs/Python/Python39/python.exe c:/Users/Admin
Traceback (most recent call last):
  File "c:\Users\Admin\Desktop\aldini\Aldini.py", line 139, in <module>
    order=Order(DATASET)
  File "c:\Users\Admin\Desktop\aldini\Aldini.py", line 41, in __init__
    self.INIT_BALANCE=float(client.balance()[0]['balance'])
KeyError: 0
D'avance merci pour toute aide apportée :)