def update_graph(pair, interval):
if pair is None: return
if interval is None: return
# candle_type = unique_pairs[pair.upper()]
# data = candle_type.query.order_by(candle_type.time.desc()).limit(24 * 60).all()
data = generate_intervals(pair, int(interval))
time_periods = [datetime.fromtimestamp(x.time) for x in data]
candle_data = go.Candlestick(
x=time_periods,
open=[x.open for x in data],
high=[x.high for x in data],
low=[x.low for x in data],
close=[x.close for x in data],
increasing=dict(fillcolor='rgb(65, 185, 137)', line=dict(color='rgb(65, 185, 137)')),
decreasing=dict(fillcolor='rgb(244, 76, 95)', line=dict(color='rgb(244, 76, 95)')),
name='Price',
showlegend=False,
)
volumes = [x.volume for x in data]
volume_data = go.Bar(
x=time_periods,
y=volumes,
name='Volume',
)
vwap_data = go.Scatter(
x=time_periods,
y=list(map(lambda x: x.vwap if x.vwap > 0 else (x.open + x.close) / 2, data)),
name='Vwap',
fillcolor='orange',
mode='markers',
marker=dict(color='orange', size=3),
showlegend=False,
)
fig = make_subplots(specs=[[{"secondary_y": True}]])
fig.add_trace(volume_data, secondary_y=False)
fig.add_trace(candle_data, secondary_y=True)
fig.add_trace(vwap_data, secondary_y=True)
update_layout(fig,
time_periods[min(120, len(time_periods) - 1)],
time_periods[0] + timedelta(minutes=int(interval) * 5),
max(volumes) * 3)
return fig
def chart(df):
candlestick = go.Candlestick(x=df['open_time'], open=df['open'], high=df['high'], low=df['low'], close=df['close'])
upper_band = go.Scatter(x=df['open_time'], y=df['upper_band'], name='Upper Bollinger Band', line={'color': 'red'})
lower_band = go.Scatter(x=df['open_time'], y=df['lower_band'], name='Lower Bollinger Band', line={'color': 'red'})
upper_keltner = go.Scatter(x=df['open_time'], y=df['upper_keltner'], name='Upper Keltner Channel',
line={'color': 'blue'})
lower_keltner = go.Scatter(x=df['open_time'], y=df['lower_keltner'], name='Lower Keltner Channel',
line={'color': 'blue'})
fig = go.Figure(data=[candlestick, upper_band, lower_band, upper_keltner, lower_keltner])
fig.layout.xaxis.type = 'category'
fig.layout.xaxis.rangeslider.visible = False
fig.show()
def __init__(self, stock_data):
self.data = [
go.Candlestick(x=stock_data.index,
open=stock_data['open'],
high=stock_data['high'],
low=stock_data['low'],
close=stock_data['close'])
]
self.indicators = []
self.fig = go.Figure(data=self.data)
self.annotations = []
self.smallfont = dict(family="Courier New, monospace",
size=8,
color="#000000")
def _vnquant_candle_stick_source(symbol,
start_date,
end_date,
colors=['blue', 'red'],
width=800,
height=600,
show_vol=True,
data_source='VND',
**kargs):
loader = DataLoader.DataLoader(symbol,
start_date,
end_date,
minimal=True,
data_source=data_source)
data = loader.download()
symbol = list(data.columns.levels[1])[0]
data.columns = ['high', 'low', 'open', 'close', 'adjust', 'volume']
title = '{} stock price & volume from {} to {}'.format(
symbol, start_date, end_date)
fig = make_subplots(
rows=2,
cols=1,
shared_xaxes=True,
vertical_spacing=0.02,
# subplot_titles=('Price', 'Volume'),
row_heights=[0.6, 0.4])
fig.append_trace(go.Candlestick(x=data.index,
open=data['open'],
high=data['high'],
low=data['low'],
close=data['close'],
increasing_line_color=colors[0],
decreasing_line_color=colors[1]),
row=1,
col=1)
if show_vol:
fig.append_trace(go.Bar(x=data.index, y=data['volume'], name='Volume'),
row=2,
col=1)
fig.update_layout(title=title,
yaxis_title='Price',
xaxis_title='Date',
width=width,
height=height,
showlegend=False)
fig.show()
def create_plot_financial(stock_name):
df_y = pdr.DataReader(str(stock_name) + '.bk',
data_source='yahoo',
start='2018-01-01')
# a = df_y.iloc[0]['High']
set1 = go.Candlestick(x=df_y.index,
open=df_y['Open'],
high=df_y['High'],
low=df_y['Low'],
close=df_y['Close'])
set2 = go.Scatter(x=df_y.index, y=df_y['High'] + df_y['High'])
data = [set1, set2]
graphJSON = json.dumps(data, cls=plotly.utils.PlotlyJSONEncoder)
return graphJSON
def quotes_chart(data):
fig = go.Figure(data=[
go.Candlestick(
x=data['Date'],
open=data['Open'],
high=data['High'],
low=data['Low'],
close=data['Close'],
increasing_line_color='green',
decreasing_line_color='red',
)
])
fig.update_layout(title="Stock Quotes")
st.plotly_chart(figure_or_data=fig)
def update_monthly(exchange, leverage, start_date, end_date):
dff = filter_df(exchange, leverage, start_date, end_date)
data = calc_returns_over_month(dff)
btc_returns = calc_btc_returns(dff)
strat_returns = calc_strat_returns(dff)
strat_vs_market = strat_returns - btc_returns
# for pnl graph
shortval = dff[dff["Trade type"] == "Short"]["Pnl (incl fees)"]
longval = dff[dff["Trade type"] == "Long"]["Pnl (incl fees)"]
shortbar = go.Bar(x=dff["Entry time"], y=shortval, name="Short")
longbar = go.Bar(x=dff["Entry time"], y=longval, name="Long")
# line charts
trace_btc = go.Scatter(x=dff["Entry time"],
y=dff["BTC Price"],
mode="lines")
trace_portfolio = go.Scatter(x=dff["Entry time"],
y=dff['Exit balance'] +
dff['Pnl (incl fees)'],
mode="lines")
return (
{
"data": [
go.Candlestick(
open=[each["entry"] for each in data],
close=[each["exit"] for each in data],
x=[each["month"] for each in data],
low=[each["entry"] for each in data],
high=[each["exit"] for each in data],
)
],
"layout": {
"title": "Overview of Monthly performance"
},
},
f"{btc_returns:0.2f}%",
f"{strat_returns:0.2f}%",
f"{strat_vs_market:0.2f}%",
{
"data": [shortbar, longbar],
"layout": go.Layout(title="PnL vs Trade type")
},
{
"data": [trace_btc],
"layout": go.Layout(title="Daily BTC Price")
},
{
"data": [trace_portfolio],
"layout": go.Layout(title="Balance overtime")
},
)
def plot_candlestick_chart(ticker):
df = pd.read_csv('~/Documents/project_ticker_data.csv')
df.drop(columns=['Unnamed: 0'], inplace=True)
df.set_index('ticker', inplace=True)
ticker_df = df.loc[ticker]
fig = go.Figure(data=[
go.Candlestick(x=ticker_df['Date'],
open=ticker_df['Open'],
high=ticker_df['High'],
low=ticker_df['Low'],
close=ticker_df['Close'])
])
#fig.show()
return fig.show()
def _create_figure(self, performance_keys: dict) -> None:
fig = make_subplots(
rows=4,
cols=1,
shared_xaxes=True,
vertical_spacing=0.03,
row_heights=[0.55, 0.15, 0.15, 0.15],
)
fig.add_trace(go.Candlestick(name='Price',
xaxis='x1',
yaxis='y1',
showlegend=False),
row=1,
col=1)
fig.update_layout(xaxis_rangeslider_visible=False)
fig.add_trace(go.Bar(name='Volume',
showlegend=False,
marker={'color': 'DodgerBlue'}),
row=2,
col=1)
for k in performance_keys:
fig.add_trace(go.Scatter(mode='lines', name=k), row=3, col=1)
fig.add_trace(go.Scatter(mode='lines',
name='Net Worth',
marker={'color': 'DarkGreen'}),
row=4,
col=1)
fig.update_xaxes(linecolor='Grey', gridcolor='Gainsboro')
fig.update_yaxes(linecolor='Grey', gridcolor='Gainsboro')
fig.update_xaxes(title_text='Price', row=1)
fig.update_xaxes(title_text='Volume', row=2)
fig.update_xaxes(title_text='Performance', row=3)
fig.update_xaxes(title_text='Net Worth', row=4)
fig.update_xaxes(title_standoff=7, title_font=dict(size=12))
self.fig = go.FigureWidget(fig)
self._price_chart = self.fig.data[0]
self._volume_chart = self.fig.data[1]
self._performance_chart = self.fig.data[2]
self._net_worth_chart = self.fig.data[-1]
self.fig.update_annotations({'font': {'size': 12}})
self.fig.update_layout(template='plotly_white',
height=self._height,
margin=dict(t=50))
self._base_annotations = self.fig.layout.annotations
def series_figure(self, records):
rows = len(self.index_for_graph)
fig = make_subplots(rows=rows,
cols=1,
shared_xaxes=True,
vertical_spacing=0.02)
row = 1
for i in self.index_for_graph:
r = records[i]
recorder = self.recorders[i]
if isinstance(recorder, CandleRecorder):
candle = go.Candlestick(x=r.index,
open=r['open'],
high=r['high'],
low=r['low'],
close=r['close'],
name='S5')
fig.add_trace(candle, row=row, col=1)
if isinstance(recorder, MACDRecorder):
macd = go.Scatter(x=r.index,
y=r[recorder.macd_key],
name=recorder.macd_key)
signal = go.Scatter(x=r.index,
y=r[recorder.signal_key],
name=recorder.signal_key)
fig.add_trace(macd, row=row, col=1)
fig.add_trace(signal, row=row, col=1)
if isinstance(recorder, ADXRecorder):
adx = go.Scatter(x=r.index,
y=r[recorder.adx_key],
name=recorder.adx_key)
plus_di = go.Scatter(x=r.index,
y=r[recorder.plus_di_key],
name=recorder.plus_di_key)
minus_di = go.Scatter(x=r.index,
y=r[recorder.minus_di_key],
name=recorder.minus_di_key)
fig.add_trace(adx, row=row, col=1)
fig.add_trace(plus_di, row=row, col=1)
fig.add_trace(minus_di, row=row, col=1)
row += 1
fig.update_layout(height=800, xaxis_rangeslider_visible=False)
return fig
def Stock_Select(request):
if request.method == 'POST':
stock = request.form.get('symb')
stockstdate = request.form.get('start')
stockedate = request.form.get('end')
stockv = yf.Ticker(stock)
sdate = (stockstdate)
edate = (stockedate)
data_df = yf.download(stock, start=sdate, end=edate)
data_df2 = data_df.reset_index(drop=False)
#data_df.index = [x for x in range(1, len(data_df.values)+1)]
#data_df.index.name = 'id'
#data_df.index = data_df.index.map(str)
data_df2.columns = [ "Date", "OPEN", "HIGH", "LOW", "CLOSE", "ADJ Close", "Volume"]
data_df2 = data_df2.round({"OPEN": 2, "HIGH": 2, "LOW": 2, "CLOSE": 2})
# prof = pr(data_df2)
# prof.to_file(output_file='templates/profile.html')
fig = go.Figure(data=[go.Candlestick(x=data_df2["Date"],
open=data_df2['OPEN'], high=data_df2['HIGH'],
low=data_df2['LOW'], close=data_df2['CLOSE'])
])
fig.update_layout(
title="Requested Stock Info",
yaxis_title=f"{stock}",
paper_bgcolor='rgba(0,0,0,0)',
plot_bgcolor='rgba(0,0,0,0)'
)
fig.update_xaxes(showgrid=False)
fig.update_yaxes(showgrid=False)
fig.update_layout(autosize=False, width=800, height=500)
fig.write_html('templates/StockETL.html')
data_df2.to_csv('../data/StockETL.csv', index = True)
stock_json = data_df2.to_json(orient="records", date_format='iso')
final_json = json.loads(stock_json)
json.dumps(stock_json, indent=0)
with open('../data/Searchedstock.json', 'w') as json_file:
json.dump(final_json, json_file)
def tplot_candle(transactions, absval=False, dt='day', key='bal', log=False, statistic='median', title=None):
'''
Produces a candlestick plot of the specified list of transactions.
'''
if statistic == 'median':
statfunc = statistics.median
else:
statfunc = statistics.mean
fig = go.Figure()
dopen = []
dhigh = []
dlow = []
dclose = []
dates = sorted(list(set([t['date'] for t in transactions])))
for d in dates:
data = [t[key] for t in transactions if t['date'] == d]
if absval:
data = list(map(abs, data))
dhigh.append(max(data))
dlow.append(min(data))
if len(data) == 1:
dopen.append(data[0])
dclose.append(data[0])
elif len(data) == 2:
dopen.append(max(data))
dclose.append(min(data))
else:
data_avg = statfunc(data)
data_stdev = statistics.stdev(data)
dopen.append(data_avg + (data_stdev / 2))
dclose.append(data_avg - (data_stdev / 2))
fig.add_trace(go.Candlestick(
x = dates,
high = dhigh,
open = dopen,
close = dclose,
low = dlow
))
if key == 'amount':
yt = 'Transaction Amount ($)'
elif key == 'bal':
yt = 'Account Balance ($)'
fig.update_layout(
title = title,
xaxis_title = 'Date',
yaxis_title = yt,
yaxis_type = 'log' if log else 'linear'
)
return fig
def get_candlestick_chart(**kwargs):
data2plot = kwargs['data2plot']
if 'num_panels' in kwargs.keys():
num_panels = kwargs['num_panels']
else:
num_panels = 1
if 'open_price' in data2plot.columns:
data2plot.rename(columns={'open_price': 'open'}, inplace=True)
if 'high_price' in data2plot.columns:
data2plot.rename(columns={'high_price': 'high'}, inplace=True)
if 'low_price' in data2plot.columns:
data2plot.rename(columns={'low_price': 'low'}, inplace=True)
if 'close_price' in data2plot.columns:
data2plot.rename(columns={'close_price': 'close'}, inplace=True)
fig = make_subplots(rows=num_panels, cols=1)
fig.add_trace(go.Candlestick(x=data2plot.index,
open=data2plot['open'],
high=data2plot['high'],
low=data2plot['low'],
close=data2plot['close'],
name='underlying'),
row=1,
col=1)
fig.update(layout_xaxis_rangeslider_visible=False)
if 'main_panel_indicator_list' in kwargs.keys():
main_panel_indicator_list = kwargs['main_panel_indicator_list']
color_list = ['black', 'purple', 'blue']
for i in range(len(main_panel_indicator_list)):
fig.add_trace(go.Scatter(x=data2plot.index,
y=data2plot[main_panel_indicator_list[i]],
line=dict(color=color_list[i]),
name=main_panel_indicator_list[i]),
row=1,
col=1)
if 'rsi_14' in data2plot.columns:
fig.add_trace(go.Scatter(x=data2plot.index, y=data2plot['rsi_14']),
row=2,
col=1)
fig.update(layout_xaxis_rangeslider_visible=False)
fig.show()
def plotCandlesticks():
df = pd.read_csv('datasets/LTC.csv', parse_dates=['Date'])
fig = go.Figure()
fig.add_trace(
go.Candlestick(x=df['Date'],
open=df['Open'],
high=df['High'],
low=df['Low'],
close=df['Close'],
name='LTC'))
fig.update_layout(title="LTC/USDT",
xaxis_title="Time",
yaxis_title="Price")
fig.show()
def display_candle(self):
df = pd.DataFrame(self.histo_data.values,
columns=['open', 'high', 'low', 'last_price'])
df['Date'] = self.histo_data.axes[0]
fig = go.Figure(data=[
go.Candlestick(x=df['Date'],
open=df['open'],
high=df['high'],
low=df['low'],
close=df['last_price'])
])
fig.update_layout(
title=self.tick,
xaxis_rangeslider_visible=False) # Remove to add range slider
fig.show()
def make_plot(self):
#Extracting data
df = get_data("{ticker}".format(ticker=self.e1.get()),
start_date = self.e2.get(), end_date = self.e3.get())
df.index = pd.to_datetime(df.index)
fig = go.Figure(data=[go.Candlestick(x=df.index,
open=df['open'],
high=df['high'],
low=df['low'],
close=df['close'])])
fig.show()
def get_candlestick_data(ticker, startdate, enddate):
# Pull Stock Data
stock_data = pd.DataFrame()
stock_data = wb.DataReader(ticker,
data_source="yahoo",
start=startdate,
end=enddate)
candlestick = go.Candlestick(x=stock_data.index,
open=stock_data['Open'],
high=stock_data['High'],
low=stock_data['Low'],
close=stock_data['Close'])
save_fig(candlestick, ticker)
def _plot_stock_data(df: pd.DataFrame, head: int):
if head:
df = df.tail(head)
stock_data = go.Candlestick(
x=df["day"],
open=df["open"],
high=df["high"],
low=df["low"],
close=df["close"],
increasing_line_color="red",
decreasing_line_color="green",
name="stock price",
)
return stock_data
def get_ytd_chart(self):
""" Gets a one year candlestick chart of stock
:return:
Plotly chart: one year candlestick chart
"""
df = self.get_one_year_historical_prices()
for table in df:
df = table[0].loc[::-1] # reverse order of column values
fig = go.Figure(data=[go.Candlestick(x=df['Date'],
open=df['Open'],
high=df['High'],
low=df['Low'],
close=df['Close*'])])
fig.show()
def update_candlestick_plot(data):
fig = go.Figure(data=[
go.Candlestick(x=data['fecha'],
open=data['open'],
high=data['high'],
low=data['low'],
close=data['close'])
])
fig.update_layout(xaxis_rangeslider_visible=False,
margin=dict(t=0, l=55, r=50, b=30),
template='plotly_white',
height=400)
return fig
async def stock(ctx, symbol: str):
symbol = symbol.upper()
try:
price = stocks.latest_price(symbol)
except:
embed = add_embed(f'Could\'t find information for "{symbol}"',
'check spelling and symbol!')
await ctx.send(embed=embed)
return
open, high, low = stocks.get_stats(symbol)
trend = rnd(price - open)
trend_perc = rnd((price - open) / open * 100)
if trend > 0:
trend = f'+${trend}'
trend_perc = f'+{trend_perc}%'
else:
trend = f'-${abs(trend)}'
trend_perc = f'-{abs(trend_perc)}%'
fields = [
('Current Price', f'${price}'),
('Open Price', f'${open}'),
('High Price', f'${high}'),
('Low Price', f'${low}'),
('Trend Today', trend),
('Trend Today %', trend_perc),
]
o, h, l, c = stocks.get_aggregate(symbol)
layout = go.Layout(paper_bgcolor='rgba(0,0,0,0)',
plot_bgcolor='rgba(0,0,0,0)',
width=1200,
height=800,
xaxis=go.layout.XAxis(showticklabels=False),
yaxis=go.layout.YAxis(color="white"))
fig = go.Figure(data=[go.Candlestick(open=o, high=h, low=l, close=c)],
layout=layout)
fig.update_layout(xaxis_rangeslider_visible=False)
if not os.path.exists('images'):
os.mkdir('images')
fig.write_image("images/" + symbol + ".png")
file = discord.File("images/" + symbol + ".png", filename='image.png')
embed = add_embed(title=symbol,
description=f'Stats as of ({sdate()})',
fields=fields,
author=ctx.author,
inline=True,
image='attachment://image.png')
await ctx.send(file=file, embed=embed)
os.remove('images/' + symbol + '.png')
def get_candlestick_plot(df, symbol):
#get company name
company = st.sidebar.text_input("Company", company_name)
# select time using buttons on top of chart
st.subheader('Choose date range for chart')
#Display the close price
st.header(company_name + ' Stock price \n')
st.subheader(listed_at + ': ' + symbol.upper())
fig = go.Figure(data=[
go.Candlestick(x=df['Date'],
open=df['Open'],
high=df['High'],
low=df['Low'],
close=df['Close'])
])
fig.update_xaxes(
rangeslider_visible=True,
rangeselector=dict(buttons=list([
dict(count=1, label="1m", step="month", stepmode="backward"),
dict(count=6, label="6m", step="month", stepmode="backward"),
dict(count=1, label="YTD", step="year", stepmode="todate"),
dict(count=1, label="1y", step="year", stepmode="backward"),
dict(step="all")
])))
fig.update_layout(title='Candlestick graph',
yaxis_title=symbol.upper() + ' Stock',
width=1150,
height=500,
shapes=[
dict(x0='2016-12-09',
x1='2016-12-09',
y0=0,
y1=1,
xref='x',
yref='paper',
line_width=2)
],
annotations=[
dict(x='2016-12-09',
y=0.05,
xref='x',
yref='paper',
showarrow=False,
xanchor='left',
text='Increase Period Begins')
])
return fig
def get_plot(self, dfp, symbol, hband, lband, atrmh, atrml):
''' plotly candlestick chart '''
fig = go.Figure()
trace1 = go.Candlestick(x=dfp.index,
open=dfp['Open'],
high=dfp['High'],
low=dfp['Low'],
close=dfp['Close'],
name=symbol)
trace2 = go.Scatter(x=hband.index,
y=hband.values,
mode='lines',
line_color='blue',
name='high band')
trace3 = go.Scatter(x=lband.index,
y=lband.values,
mode='lines',
line_color='blue',
name='low band')
trace4 = go.Scatter(x=pd.Series(dfp.index[-1]),
y=[atrmh],
name='long_alert_value',
mode='markers+text',
marker_size=10,
marker_color='black',
marker_symbol='triangle-up',
text=['alert_threshold'],
textposition='middle right')
trace5 = go.Scatter(x=pd.Series(dfp.index[-1]),
y=[atrml],
name='short_alert_value',
mode='markers+text',
marker_size=10,
marker_color='black',
marker_symbol='triangle-down',
text=['alert_threshold'],
textposition='middle right')
fig.add_trace(trace1)
fig.add_trace(trace2)
fig.add_trace(trace3)
fig.add_trace(trace4)
fig.add_trace(trace5)
fig.update(layout_xaxis_rangeslider_visible=False)
fig.update_layout(title='Breakout Analysis: ' + symbol,
xaxis_title="Date",
yaxis_title="Price")
return fig
def parse(self, response):
chart = []
for i in range(
238): #21 useless info before + 30 days * 7 info per day
chart.append(
response.xpath('//span/text()')[i].get()) #get the i-th text
open_data = []
high_data = []
low_data = []
close_data = []
month_dict = {
"Jan": 1,
"Feb": 2,
"Mar": 3,
"Apr": 4,
"May": 5,
"Jun": 6,
"Jul": 7,
"Aug": 8,
"Sep": 9,
"Oct": 10,
"Nov": 11,
"Dec": 12
}
dates = []
for i in range(28, 238, 7):
#date example: "Sep 09, 2019"
dates.append(
datetime(year=int(chart[i][8:]),
month=month_dict[chart[i][:3]],
day=int(chart[i][4:6])))
open_data.append(float(chart[i + 1].replace(",", "")))
high_data.append(float(chart[i + 2].replace(",", "")))
low_data.append(float(chart[i + 3].replace(",", "")))
close_data.append(float(chart[i + 4].replace(",", "")))
fig = go.Figure(data=[
go.Candlestick(x=dates,
open=open_data,
high=high_data,
low=low_data,
close=close_data)
])
#add title, disable bottom rangeslider
fig.update_layout(title=self.target + " Prices",
xaxis_rangeslider_visible=False)
fig.show()
def updatePlot(securityValue, indicatorValues):
df = (dfPool[dfPool['security'] == securityValue])
rowWidth = [0.2 / len(indicators) for x in indicators]
rowWidth.append(0.8)
# rowWidth.append(0.6)
# specs = [[{"rowspan": 2}], [None], [{}], [{}], [{}]]
fig = make_subplots(
rows=len(indicators) + 1,
cols=1,
shared_xaxes=True,
vertical_spacing=0.1,
row_width=rowWidth,
# specs=specs,
)
fig.add_trace(go.Candlestick(x=df['datetime'],
open=df['open'],
high=df['high'],
low=df['low'],
close=df['close'],
name=securityValue),
row=1,
col=1)
fig.update_layout(
xaxis_rangeslider_visible=False,
yaxis=dict(autorange=True, fixedrange=False),
xaxis={
'type': 'category',
'categoryorder': 'category ascending'
},
# yaxis2_domain = [0, 1]
)
rowIndex = 2
if (indicatorValues): #rendering indicator plots based on dropdown
for i in indicatorValues:
fig.add_trace(go.Scatter(x=df['datetime'],
y=df[i],
mode='lines',
name=i),
row=rowIndex,
col=1)
rowIndex += 1
figure = Currentfig = fig
return figure
def plot_historical_price_chart(ticker, api_key):
p = get_historical_prices(ticker, api_key)
fig = go.Figure(data=[
go.Candlestick(x=p.index,
open=p['open'],
high=p['high'],
low=p['low'],
close=p['close'])
])
fig.update_layout(title="{} Stock Chart".format(ticker),
xaxis_title="Year",
yaxis_title="Price")
fig.show()
def display_candlestick(value):
df = next(gen(df))
df2 = df.copy()
fig = go.Figure(go.Candlestick(
x=df['Date'],
open=df['AAPL.Open'],
high=df['AAPL.High'],
low=df['AAPL.Low'],
close=df['AAPL.Close']
))
# fig.update_layout(
# xaxis_rangeslider_visible='slider' in value
# )
return fig
def historic_model(df):
"""
Returns a plotly visualization of the historic stock price
"""
fig = go.Figure(data=[
go.Candlestick(x=df["Date"],
open=df["Open"],
high=df["High"],
low=df["Low"],
close=df["Close"])
],
layout=fig_layout)
graphJSON = json.dumps(fig, cls=plotly.utils.PlotlyJSONEncoder)
return graphJSON
def graph_daily_candle(empresa):
query = f"select a.* from (select *,max(id) over (partition by ticker,date) mx_version from acoesdiario where ticker = '{empresa}')as a where mx_version = id"
data = ServerManager().SelectAllData(query=query)
df = pd.DataFrame.from_dict(data)
grafico = [
go.Candlestick(x=df['date'],
open=df['open'],
high=df['high'],
low=df['low'],
close=df['close'])
]
graficoJson = json.dumps(grafico, cls=plotly.utils.PlotlyJSONEncoder
) #Transformando o grafico em json
return graficoJson
def plot(self): # pragma: no cover
"""Item or slice
Usage:
>>> from rndqts.quotes.synthetic import Synthetic
>>> quotes = Synthetic(seed=42, cached=False)[:60]
>>> quotes.plot() # doctest: +SKIP
"""
df = self.data
cndstick = go.Candlestick(x=df.index,
open=df['Open'],
high=df['High'],
low=df['Low'],
close=df['Close'])
fig = go.Figure(data=[cndstick])
fig.show()
