Exemple #1
0
 def update(self, dataline):
     #recupera una nuova lista di dati
     #L'arrivo di dati non validi o l'assenza di dati è simulata come arrivo di un dato None
     if dataline != None: #caso arrivo valido
         datalist = split_csvline_yf(dataline)##; print(datalist)
         #aggiorna dati quad
         self.ds_quads.data["top"].append(datalist[4])
         self.ds_quads.data["bottom"].append(datalist[1])
         self.ds_quads.data["left"].append(datalist[0] - self.quadwidth / 2)
         self.ds_quads.data["right"].append(datalist[0] + self.quadwidth / 2)
         if datalist[4] > datalist[1]: self.ds_quads.data["fill_color"].append("green")
         else: self.ds_quads.data["fill_color"].append("red")
         #aggiorna dati segment
         self.ds_segments.data["x0"].append(datalist[0])
         self.ds_segments.data["x1"].append(datalist[0])
         self.ds_segments.data["y0"].append(datalist[3])
         self.ds_segments.data["y1"].append(datalist[2])
         #aggiorna i dati x_range di plot
         #in caso di arrivo dato valido, definisce un intervallo di visualizzazione ponendo la candela del dato in
         #arrivo a mezzo tmstep dal bordo dx del grafico e a candle_visualized_n + 0.5 tmstep dal bordo sx
         self.plot.x_range.start = datalist[0] - (self.candle_visualized_n - 0.5) * self.tmstep
         self.plot.x_range.end = datalist[0] + 0.5 * self.tmstep
     else: #caso ricezione dato non valido
         #shifta di un tmstep a sx l'intervallo di visualizzazione nell'asse x e non aggiunge candele al grafico
         #NB: mentre in caso arrivo dati validi stabilisce il range di visualizzazione in base all'ascissa del dato
         #arrivato, qui effettua lo shift con tmstep. Se tmstep non è preso esattamente pari alla distanza temporale
         #tra l'arrivo di due dati:
         #arrivo dati validi: mostra un intervallo in x non esattamente uguale a quello desiderato
         #arrivo dati non validi o asenza dati: qui accumula ritardo o anticipo rispetto ai dati attuali
         self.plot.x_range.start += self.tmstep 
         self.plot.x_range.end += self.tmstep
     #ritorna una lista degli oggetti di cui fare push: data sources dei glifi e x_range di plot
     return [self.ds_quads, self.ds_segments, self.plot.x_range]
Exemple #2
0
 def update(self, dataline):
 #supposto che, in caso di arrivo dati non validi o assenza dati, si riceve None
     if dataline != None: #in caso di arrivo dati validi
         datalist = split_csvline_yf(dataline, "str")
         shift_insert(self.plot.source.data["dates"], datalist[0])
         shift_insert(self.plot.source.data["close"], datalist[4])
         shift_insert(self.plot.source.data["delta"], self.plot.source.data["close"][-1] - self.plot.source.data["close"][-2])
     else: #in caso di assenza dati o arrivo dati non validi
         pass #non aggiunge alcun dato alla tabella, aspettando il dato successivo. Il prossimo delta è calcolato tra il primo e
     #non aggiunge alcun dato alla tabella, aspettando il dato successivo. Il prossimo delta è calcolato tra il primo e
     #l'ultimo dato prima che vi sia stata assenza degli stessi
     return [self.plot.source] #ritorna il data source delle colonne, wrappato in lista per poterlo estrarre nel modo più generale
 def update(self, x_dataline, y_dataline):
     if x_dataline == None or y_dataline == None: #caso in cui si ha assenza di dati di almeno un titolo
     #suppone che, se per un titolo un giorno non ci sono dati, al posto della linea da esso attesa riceve None
     #Se riceve None, cancella la memoria dei dati dei titoli x e y relativi al tick temporale precedente (per 
     #calcolare un delta valido servono due dati validi consecutivi sia del titolo x che del titolo y)
         self.x_olddata = None
         self.y_olddata = None
     else: #casi in cui entrambi i dati x e y ricevuti al corrente tick temporale sono validi
     #se è la prima volta che riceve dei dati non appende alcun dato al ds del plot (non si può calcolare un delta)
     #ma semplicemente salva tali dati per calcolare il delta alla ricezione dei successivi dati (se validi)
         x_datalist = split_csvline_yf(x_dataline)
         y_datalist = split_csvline_yf(y_dataline)
         if self.x_olddata != None: #caso in cui anche i dati x e y ricevuti al tick temporale precedente sono validi
         #Appende al ds del plot un punto con ascissa pari al delta tra il valore del titolo x ricevuto a questo tick
         #temporale e al tick temporale precedente, e ordinata calcolata analogamente con i dati del titolo y
             self.ds.data["x"].append(x_datalist[4]-self.x_olddata)
             self.ds.data["y"].append(y_datalist[4]-self.y_olddata)
         #dati ricevuti memorizzati come relativi al tick temporale precedente alla prossima chiamata
         self.x_olddata = x_datalist[4] 
         self.y_olddata = y_datalist[4]
         #ritorna il ds del plot aggiornato con ascissa e ordinata del punto da plottare calcolate dai dati forniti
     return [self.ds] #wrap in lista, per poter effettuare l'estrazione degli oggetti aggiornati nel modo più generico
Exemple #4
0
 def csvlines_to_data_yf(self, csvlines):
     data = [None, None]
     for i in range(2):
         if csvlines[i] != None: data[i] = split_csvline_yf(csvlines[i], "byte")[4] #utilizza close
         else: pass
     return data
Exemple #5
0
 def csvlines_to_datalist_yf(self, csvlineslist):
     if csvlineslist[0] == None: datalist = [None]
     else: datalist = split_csvline_yf(csvlineslist[0], "str")[0::4]
     return datalist       
Exemple #6
0
 def csvlines_to_data_yf(self, csvlines):
     if csvlines[0] == None: data = [None]
     else: data = split_csvline_yf(csvlines[0], "int")[0:5]
     return data
Exemple #7
0
 def csvlines_to_data_yf(self, csvlines):
     if csvlines[0] == None: data = [None]
     else: data = split_csvline_yf(csvlines[0], "str")[0::4] #sottolista con data formato str e close
     return data