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]
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
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
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
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
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
