def setMainGraph(stocks, start_date, end_date): ##filtering by date # print (type(datetime.strptime(start_date, '%Y-%m-%d').date()), start_date) # print (type(datetime.strptime(end_date, '%Y-%m-%d').date()), end_date) # print (type(data['timestamp'][0]),data['timestamp'][0]) filtered_data = data[ (data['timestamp'] > datetime.strptime(start_date, '%Y-%m-%d').date()) & (data['timestamp'] < datetime.strptime(end_date, '%Y-%m-%d').date())] print('Running setMainGraph, stock input: ', stocks) ##stock picker returns an array title = "Stock chart for" traces = [] if len(stocks) == 1: title = f"Stock chart for {stocks[0]}" traces.append( go.Ohlc(x=filtered_data[filtered_data['symbol'] == stocks[0]]['timestamp'].tolist(), open=filtered_data[filtered_data['symbol'] == stocks[0]]['open'].tolist(), high=filtered_data[filtered_data['symbol'] == stocks[0]]['high'].tolist(), low=filtered_data[filtered_data['symbol'] == stocks[0]]['low'].tolist(), close=filtered_data[filtered_data['symbol'] == stocks[0]] ['close'].tolist(), name=stocks[0])) elif len(stocks) > 1: for stock in stocks: title = title + " " + stock print(f'Generating {stock}') traces.append( go.Ohlc(x=filtered_data[filtered_data['symbol'] == stock]['timestamp'].tolist(), open=filtered_data[filtered_data['symbol'] == stock]['open'].tolist(), high=filtered_data[filtered_data['symbol'] == stock]['high'].tolist(), low=filtered_data[filtered_data['symbol'] == stock]['low'].tolist(), close=filtered_data[filtered_data['symbol'] == stock] ['close'].tolist(), name=stock)) return { 'data': traces, 'layout': go.Layout(paper_bgcolor="#393846", plot_bgcolor="#393846", font={'color': '#a2a1af'}, xaxis={'color': '#a2a1af'}, yaxis={'color': '#a2a1af'}, title=title # colorscale= {'color': '#a2a1af'} ) }
def getStock(self, stockname, startTime, endTime): filename = stockname + "-" + fileBaseName(startTime, endTime) filePath = imageFolder +'/' + filename # to be replaced by market data service # df = web.DataReader(stockname, 'morningstar', startTime, endTime).reset_index() MDS = MarketDataService() df = MDS.get_df(stockname, 'morningstar', startTime, endTime) trace = go.Ohlc(x=df.Date, open=df.Open, high=df.High, low=df.Low, close=df.Close) layout = go.Layout( xaxis = dict( rangeslider = dict( visible = False ) ) ) data = [trace] fig = go.Figure(data=data, layout=layout) plt.image.save_as(fig, filename=Path(filePath)) return(self.showResult(stockTemplate, imageFolder, filename))
def getCrypto(self, symbol, market, startTime, endTime, timeframe=None): filename = symbol + "-" + fileBaseName(startTime, endTime) filePath = imageFolder +'/' + filename MDS = MarketDataService() df = MDS.get_crypto(symbol, market, startTime, endTime, timeframe) trace = go.Ohlc(x=df.date, open=df.a0, high=df.a2, low=df.a4, close=df.a6) layout = go.Layout( xaxis = dict( rangeslider = dict( visible = False ) ) ) data = [trace] fig = go.Figure(data=data, layout=layout) plt.image.save_as(fig, filename=Path(filePath)) return(self.showResult(stockTemplate, imageFolder, filename))
def plot_ohlc(df, stock_name): trace = go.Ohlc(x=df['<DTYYYYMMDD>'], open=df['<Open>'], high=df['<High>'], low=df['<Low>'], close=df['<Close>'], increasing=dict(line=dict(color='#58FA58')), decreasing=dict(line=dict(color='#FA5858'))) layout = { 'title': f'{stock_name} Historical Price', 'xaxis': { 'title': 'Date', 'rangeslider': { 'visible': False } }, 'yaxis': { 'title': f'Price' } } data = [trace] fig = go.Figure(data=data, layout=layout) fig.show() return fig
def graph_OHLC(self): #not quite there, but the other one works, which is what i really care about OHLC_trace = go.Ohlc(x=self.OHLC_data.Date_Time, open=self.OHLC_data.Open, high=self.OHLC_data.High, low=self.OHLC_data.Low, close=self.OHLC_data.Close, name="OHLC Data", increasing=dict(line=dict(color='#408e4a')), decreasing=dict(line=dict(color='#cc2718'))) swing_data = pd.read_csv( self.swing_file, names=['Date_Time', 'Price', 'Direction', 'Row'], parse_dates=True) swing_trace = go.Scatter(x=swing_data.Date_Time, y=swing_data.Price, mode='lines+markers', name='Swings', line=dict(color=('rgb(111, 126, 130)'), width=3)) data = [OHLC_trace, swing_trace] layout = go.Layout(xaxis=dict(rangeslider=dict(visible=False)), title=self.data_file[:-4]) fig = go.Figure(data=data, layout=layout) py.plot(fig, filename=self.data_file + ".html", output_type='file')
def get_trace_ohlc(df, x_column='DateTime'): trace = go.Ohlc(x=df[x_column], open=df.Open, high=df.High, low=df.Low, close=df.Close) return trace
def graph_high_low_open_close(coin_name): conn = sqlite3.connect('crypto.sqlite') cur = conn.cursor() labels_for_graph = [] high_values_for_graph= [] low_values_for_graph = [] open_values_for_graph = [] close_values_for_graph = [] statement = ''' SELECT Date, High, Low , Open, Close FROM "{}" ORDER BY ID DESC '''.format(coin_name) cur.execute(statement) for i, j, k, l, m in cur: t = datetime.strptime(i.replace(',', ''), '%b %d %Y') labels_for_graph.append(t) high_values_for_graph.append(j) low_values_for_graph.append(k) open_values_for_graph.append(l) close_values_for_graph.append(m) trace = go.Ohlc(x=labels_for_graph, open=open_values_for_graph, high=high_values_for_graph, low=low_values_for_graph, close=close_values_for_graph) data = [trace] py.plot(data, filename='High-Low-Open-Close For {}'.format(coin_name))
def change_mode(value): refresh_data(crypto_symbol, value) global x_data global y_data_box_open graphs = [] graphs.append( go.Scatter(x=x_data, y=y_data_scatter, name='Manipulate Graph')) graphs.append( go.Ohlc(x=x_data, open=y_data_box_open, high=y_data_box_high, low=y_data_box_low, close=y_data_box_close)) layout = go.Layout( paper_bgcolor='#27293d', plot_bgcolor='rgba(0,0,0,0)', xaxis=dict(range=[min(x_data), max(x_data)]), yaxis=dict(range=[min(y_data_box_open), max(y_data_box_open)]), font=dict(color='white'), ) return {'data': graphs, 'layout': layout}
def analyze(context, perf): trace0 = go.Ohlc(x=perf.index.to_series(), open=perf.open, high=perf.high, low=perf.low, close=perf.close, showlegend=False) pos_values = perf.signal[perf.signal > 0] pos_high_values = perf.high[perf.high.index.isin(pos_values.index)] neg_values = perf.signal[perf.signal < 0] neg_low_values = perf.high[perf.high.index.isin(neg_values.index)] trace1 = go.Scatter(x=pos_values.index.to_series(), y=pos_high_values, mode='markers', name='Bull Break') trace2 = go.Scatter(x=neg_values.index.to_series(), y=neg_low_values, mode='markers', name='Bear Break') data = [trace0, trace1, trace2] py.plot(data, filename='simple_ohlc2')
def plot_raw_data(self, data): d = data xVar = 'Date' if ('Datetime' in d): xVar = 'Datetime' # fig = 0 # del fig #scatter object class has list of all traces # self.figure_bettername = go.Figure(go.Ohlc(x=d['Datetime'], open=d['Open'], high=d['High'], low=d['Low'], close=d['Close'])) self.figure_bettername = go.Figure( go.Ohlc(x=d[xVar], open=d['Open'], high=d['High'], low=d['Low'], close=d['Close'])) # self.figure_bettername.add_trace() # self.figure_bettername.add_trace(go.Scatter(x=d['Date'], y=d['High'], name="stock_high")) # self.figure_bettername.add_trace(go.Scatter(x=d['Date'], y=d['Low'], name="stock_low")) # self.figure_bettername.update_xaxes(rangeslider_range=d['Date']) # fig.del() # fig.add_trace(go.Scatter(x=data['Date'], y=data['Volume'], name="Volume")) # fig.layout.update(title_text='Time Series data with Rangeslider', xaxis_rangeslider_visible=True) self.chartplot.empty() self.chartplot = st.plotly_chart(self.figure_bettername)
def market_price(stock='GOOGL'): start = datetime.datetime(2019, 1, 1) end = datetime.datetime(2019, 5, 1) STOCK = web.DataReader(stock, 'yahoo', start, end) # STOCK = web.DataReader(stock, 'google', start, end) # deprecated data = go.Ohlc( x=STOCK.index[:], open=STOCK['Open'], high=STOCK['High'], low=STOCK['Low'], close=STOCK['Close'], name=stock, increasing=dict(line=dict(color='blue')), decreasing=dict(line=dict(color='red')), ) layout = { 'title': stock, 'xaxis': { 'title': 'Year to Date 2019' }, 'yaxis': { 'title': 'Price per stock ($)' } } data = dict(data=[data], layout=layout) return data
def update_figure(selected_stock): """Will show different graphs on the figure, depending on what the user selects. Will be called every single time the user changes value on the dropdown list. Parameters ---------- selected_stock : string The value selected in the dropdown list. Returns ------- figure Return the figure type information in an array with the new read figure data. """ df = get_history(selected_stock) fig = go.Figure(data=go.Ohlc(x=df['Date'], open = df['Open'], high = df['High'], low = df['Low'], close = df['Close']), layout = go.Layout( title = go.layout.Title(text="Graph Showing " + selected_stock.upper() + " Stock Price History") ) ) print(fig["layout"]) return fig
def update_figure(selected): dff = df[(df["year"] >= selected[0]) & (df["year"] <= selected[1])] trace = go.Ohlc(x=dff['date'], open=dff['open'], high=dff['high'], low=dff['low'], close=dff['close'], increasing={'line': {'color': '#00CC94'}}, decreasing={'line': {'color': '#F50030'}} ) return { 'data': [trace], 'layout': go.Layout( title=f"Stock Values for the period:{'-'.join(str(i) for i in selected)}", xaxis={ 'rangeslider': {'visible': False}, 'autorange': "reversed", }, yaxis={ "title": f'Stock Price (USD)' } )}
def create_plotting(symbol, interval): py.sign_in(PLOTLY_USER, PLOTLY_PASSWORD) df = get_stock(symbol, interval) if (df is None): return ("Error", None) else: df = df.astype(float) High = max(df['High']) Low = min(df['Low']) data_mean = np.round(df['Close'].mean(), 2) data_std = np.round(df['Close'].std(), 4) return_object = { 'high': High, 'low': Low, 'mean': data_mean, 'std': data_std } trace_stock = go.Ohlc(x=df.index, open=df.Open, high=df.High, low=df.Low, close=df.Close) trace_volume = go.Scatter(x=df.index.values, y=df['Volume'], line=dict(color=('rgb(22, 96, 167)'), width=4)) stock_label = symbol + ' ' + interval + ' interval graph' fig = tools.make_subplots(rows=4, cols=1, specs=[[{ 'rowspan': 3 }], [None], [None], [{}]], shared_xaxes=True, shared_yaxes=True, vertical_spacing=0.12, subplot_titles=(stock_label, '', '', 'Trading volume')) fig.append_trace(trace_stock, 1, 1) fig.append_trace(trace_volume, 4, 1) fig['layout'].update(xaxis=dict(rangeslider=dict(visible=False)), showlegend=False) path = 'data/plotting/' + symbol + '_graph.png' py.image.save_as(fig, filename=path) return (symbol + '_graph.png', return_object)
def RenderCoinPage(CurrentCoin): RootPage = html.Div([ html.A(html.H1(CurrentCoin.Name, style={ "color": "Black", "fontSize": 72, "textAlign": "center" }), href=CurrentCoin.Website, target="_blank"), dcc.Link("Home Page", href="/", style={ "color": "Red", "fontSize": 28 }), html.Br(), html.Div([ html.Div([ dcc.Link(Coin.Name, href="/" + Coin.Abbreviation, style={ "color": "Blue", "fontSize": 24 }) ], className="two columns") for Coin in [item for item in Coins if CurrentCoin != item] ], className="row"), dcc.Graph(figure={ "layout": go.Layout(title=CurrentCoin.Name + " Market", legend=dict(orientation="h"), xaxis=dict(type="date"), yaxis=dict(title=CurrentCoin.Name + " Prices (USD)", showticklabels=True)), "data": [ go.Ohlc(x=CurrentCoin.Date, open=CurrentCoin.Open, high=CurrentCoin.High, low=CurrentCoin.Low, close=CurrentCoin.Close) ] }, id=CurrentCoin.Name + "Graph", style={"height": 1000}), html.Ul([ html.Li( html.A(Article[0], href=Article[1], style={ "color": "Blue", "fontSize": 24 }, target="_blank")) for Article in CurrentCoin.TopStories ], style={"padding-left": 70}) ]) return RootPage
def bar_trace(df, y_col): return go.Ohlc( x=df.index, open=df[y_col], increasing=dict(line=dict(color="#888888")), decreasing=dict(line=dict(color="#888888")), showlegend=False, name="bar", )
def makeOhlcTrace(label, dates, opens, highs, lows, closes): trace = go.Ohlc(name=label, x=dates, open=opens, high=highs, low=lows, close=closes) return trace
def get_currency_graph_update(exchange_name, symbol, time_frame, cryptocurrency_name): symbol_evaluator_list = get_bot().get_symbol_evaluator_list() exchange_list = get_bot().get_exchanges_list() if time_frame is not None: if len(symbol_evaluator_list) > 0: evaluator_thread_managers = symbol_evaluator_list[symbol].get_evaluator_thread_managers( exchange_list[exchange_name]) if time_frame in evaluator_thread_managers: evaluator_thread_manager = evaluator_thread_managers[time_frame] data = evaluator_thread_manager.get_evaluator().get_data() if data is not None: _, pair_tag = split_symbol(symbol) add_to_symbol_data_history(symbol, data, time_frame) data = get_symbol_data_history(symbol, time_frame) # data.loc[:, PriceStrings.STR_PRICE_TIME.value] /= 1000 data_x = data[PriceIndexes.IND_PRICE_TIME.value] data_y = data[PriceIndexes.IND_PRICE_CLOSE.value] # Candlestick ohlc_graph = go.Ohlc(x=data[PriceIndexes.IND_PRICE_TIME.value], open=data[PriceIndexes.IND_PRICE_OPEN.value], high=data[PriceIndexes.IND_PRICE_HIGH.value], low=data[PriceIndexes.IND_PRICE_LOW.value], close=data[PriceIndexes.IND_PRICE_CLOSE.value]) real_trades_prices, real_trades_times, simulated_trades_prices, simulated_trades_times = \ get_trades_by_times_and_prices() real_trades_points = go.Scatter( x=real_trades_prices, y=real_trades_times, mode='markers', name='markers' ) simulated_trades_points = go.Scatter( x=simulated_trades_times, y=simulated_trades_prices, mode='markers', name='markers' ) return {'data': [ohlc_graph, real_trades_points, simulated_trades_points], 'layout': go.Layout( title="{} real time data (per time frame)".format(cryptocurrency_name), xaxis=dict(range=[min(data_x), max(data_x)], title=TIME_AXIS_TITLE), yaxis=dict(range=[min(data_y) * 0.98, max(data_y) * 1.02], title=pair_tag) )} return None
def colored_bar_trace(df): return go.Ohlc( x=df.index, open=df["open"], high=df["high"], low=df["low"], close=df["close"], showlegend=False, name="colored bar", )
def to_ohlc(self,id=str,dataframe=None): ohlc = go.Ohlc( x=dataframe["Date"], open=dataframe["Open"], close=dataframe["Close"], high=dataframe["High"], low=dataframe["Low"] ) final = dcc.Graph(id=id,figure=dict(data=[ohlc])) return final
def refresh_tkrTrend(tkr): start = dtm.utcnow() tFrame = pdr.DataReader(tkr, 'iex', start - timedelta(188), start) trace = go.Ohlc(x=list(tFrame.index), open=tFrame['open'], high=tFrame['high'], low=tFrame['low'], close=tFrame['close']) figure = {'data': [trace], 'layout': {'title': 'Stock Trends'}} return figure
def build_ohlcv(df, title='Intraday OHLCV Plot'): """ Builds an OHLCV candlestick plot and returns a Plotly figure """ cols = ["Open", "High", "Low", "Close", "Volume"] if not [col in df.columns for col in cols]: raise ValueError("'df' does not contain all required OHLCV columns: {}".format(cols)) # Build the OHLC candlestick trace trace1 = go.Ohlc( x=df.index, open=df["Open"], high=df["High"], low=df["Low"], close=df["Close"], name="OHLC" ) # Build the Volume barchart trace2 = go.Bar( x=df.index, y=df["Volume"], yaxis='y2', # Plot on a separate axis name="Volume", opacity=0.6, # Slightly opaque marker=dict( color='rgb(66, 134, 244)' # Blue color ) ) # Define the layout layout = go.Layout( showlegend=False, title=title, yaxis=dict( title='OHLC', side="left" ), yaxis2=dict( title='Volume', side="right", overlaying="y" # Volume plot overlays the candlestick ), template="plotly_white" ) # Aggregate the traces and build the figure data = [trace1, trace2] fig = go.Figure(data=data, layout=layout) # Return the plotly figure return fig
def plot_candlestick(stockData): ohlc = stockData.getOhlc() trace_cs = go.Ohlc(x=ohlc['Date'], open=ohlc['Open'], high=ohlc['High'], low=ohlc['Low'], close=ohlc['Close'], name='Candlestick Pattern') data = [trace_cs] fig = go.Figure(data=data) plot(fig)
def plot_olhc(value): global data dates, open_data, high_data, low_data, close_data, _ \ = data.get_ohlcv(value) return { 'data': [go.Ohlc(x=dates, open=open_data, high=high_data, low=low_data, close=close_data)], 'layout': dict(title="OHLC") }
def bar_trace(df): return go.Ohlc( x=df.index, open=df["open"], high=df["high"], low=df["low"], close=df["close"], increasing=dict(line=dict(color="#888888")), decreasing=dict(line=dict(color="#888888")), showlegend=False, name="bar", )
def plot(): plotly.tools.set_credentials_file(username='******', api_key=apiKey_pl) df = pd.read_csv('historical.csv') trace = go.Ohlc(x=df['date'], open=df['open'], high=df['high'], low=df['low'], close=df['close']) data = [trace] py.iplot(data, filename='simple_ohlc')
def plot_ohlc(df, title_str): trace = go.Ohlc(x=df.index, open=df.Open, high=df.High, low=df.Low, close=df.Close, increasing=dict(line=dict(color='red')), decreasing=dict(line=dict(color='green'))) data = [trace] iplot(data, filename=title_str)
def __genOhlcData(self, dataframe, startDate=None, endDate=None): df = dataframe.loc[startDate:endDate] trace = go.Ohlc(x=df.index, name="K Line", open=df.OpenPrice, high=df.MaxPrice, low=df.MinPrice, close=df.ClosePrice, increasing=dict(line=dict(color='#FF0000')), decreasing=dict(line=dict(color='#008000'))) return trace
def export_graphs(self, output_path): for key,value in self.wave_data.items(): my_swing_data = value[0] print("My Swing Data:", my_swing_data) lables = [] if key == "WaveC": lables = ["","","","","","","A", "B", "C"] else: lables = [str(x) for x in range(len(my_swing_data.index))] OHLC_trace = go.Ohlc(x=self.OHLC_data.index, open=self.OHLC_data.Open, high=self.OHLC_data.High, low=self.OHLC_data.Low, close=self.OHLC_data.Close, name="OHLC Data", increasing=dict(line=dict(color= '#408e4a')), decreasing=dict(line=dict(color= '#cc2718'))) print([str(x) for x in range(1, len(my_swing_data.index))]) swing_trace = go.Scatter( x = my_swing_data.Date_Time, y = my_swing_data.Price, mode = 'lines+markers+text', name = 'Swings', line = dict( color = ('rgb(111, 126, 130)'), width = 3), text=lables, textposition='top center', textfont=dict( family='sans serif', size=35, color='#2c3035' ) ) data = [OHLC_trace, swing_trace] time_frame = output_path.split("_")[-1] layout = dict( title=self.currency_name + " " + key + " " + time_frame + ": " + value[1], xaxis = dict( type="category")) fig = go.Figure(data=data, layout=layout) # offline.plot(fig, output_type='file',filename=self.currency_name + ".html", image='png', image_filename=self.currency_name) offline.plot(fig, output_type='file',filename=output_path + "_" + key + ".html", auto_open=False)
def plot_olhc(value): global data df = data.get_window_ohlcv(value) return { 'data': [ go.Ohlc(x=df.time, open=df.open, high=df.high, low=df.low, close=df.close) ], 'layout': dict(title="OHLC") }