def update_table(cutoff, show_date, num_features):
#Call model fucntion
closer_predict_display, score_table, cutoff_change_msg, feature_names, feature_imps, feature_desc_df = call_model(
show_date, cutoff, num_features)
#Create a figure with three subplots to show feature importance graph, description of features, and accuracy scores
figure = make_subplots(rows=1,
cols=3,
column_widths=[0.25, 0.5, 0.25],
specs=[[{
"type": "bar"
}, {
"type": "table"
}, {
"type": "table"
}]])
figure.add_trace(go.Bar(x=feature_names, y=feature_imps), row=1, col=1)
figure.update_yaxes(title_text="Feature Importance", row=1, col=1)
figure.update_layout(paper_bgcolor="#2C6E91",
margin=dict(l=40, r=40, t=40, b=40),
height=400),
figure.update_layout(
font=dict(family="Arial, monospace", size=14, color='#F15A50'))
figure.update_traces(marker_color='#F15A50',
marker_line_color="#2C6E91",
marker_line_width=1.5,
opacity=0.6)
figure.add_trace(go.Table(
columnwidth=[1, 3],
header=dict(values=["Feature Label", "Feature Description"],
font=dict(size=14, family="Arial, monospace"),
line_color='#2C6E91',
align="left"),
cells=dict(values=[
feature_desc_df[k].tolist() for k in feature_desc_df.columns
],
align="left",
font=dict(size=14, family="Arial, monospace"),
line_color='#2C6E91',
height=40)),
row=1,
col=2)
figure.add_trace(go.Table(
columnwidth=[2, 1],
header=dict(values=["Score Type", "Accuracy"],
font=dict(size=14, family="Arial, monospace"),
line_color='#2C6E91',
align="center"),
cells=dict(
values=[score_table[k].tolist() for k in score_table.columns],
align="center",
font=dict(size=14, family="Arial, monospace"),
line_color='#2C6E91',
height=30)),
row=1,
col=3)
#Split prediction and input table into sets for
merged_df = closer_predict_display
merged_df1 = merged_df[merged_df['set'] == '1'].copy()
merged_df2 = merged_df[merged_df['set'] == '2'].copy()
merged_df3 = merged_df[merged_df['set'] == '3'].copy()
merged_dfe = merged_df[(merged_df['set'] == 'E') |
(merged_df['set'] == 'E2')].copy()
#Pass all info back into app
return generate_table(merged_df1), generate_table(
merged_df2), generate_table(merged_df3), generate_table(
merged_dfe), cutoff_change_msg, figure
def display_header_Status_NCNA():
st.markdown(f"<div id='linkto_NbresClientsNbresAbonnés'></div>",
unsafe_allow_html=True)
df = pd.read_csv("UtilisateursVoyey.csv", index_col=0, parse_dates=True)
#print(df)
list_of_status = df['VoyeyAkaz\xa0status'].to_list()
#print(list_of_status)
Data = Counter(list_of_status)
#print()
Status = ['Actif', 'Inactive']
my_list = []
for i in Status:
Number = (Data[i])
my_list.append(Number)
#print(my_list)
#print()
print("Nombres d'inscrits':", my_list[1])
print("Nombres d'abonnés:", my_list[0])
st.markdown("Il y a **" + str(my_list[1]) + "** Inscrits et **" +
str(my_list[0]) + "** abonnés")
st.markdown("**Qui sont les nouveaux clients du jours?**")
CompteCree = df['Compte\xa0créé\xa0le'].to_list()
today = datetime.today().date()
#print(today)
The_list = []
for i in CompteCree:
Compte = datetime.strptime(i, "%d/%m/%Y").date()
#print(Compte)
Newclients = today - Compte
Newclients = Newclients.days
The_list.append(Newclients)
Prenom = df['Prénom']
P = []
for i, j in zip(The_list, Prenom):
if i == 0 or i == 1:
P.append(j)
Nom = df['Nom']
N = []
for i, j in zip(The_list, Nom):
if i == 0 or i == 1:
N.append(j)
Pays = df['Pays']
Pays1 = []
for i, j in zip(The_list, Pays):
if i == 0 or i == 1:
Pays1.append(j)
Email = df['E-mail']
E = []
for i, j in zip(The_list, Email):
if i == 0 or i == 1:
E.append(j)
Statut = df['Statut']
S = []
for i, j in zip(The_list, Statut):
if i == 0 or i == 1:
S.append(j)
C = []
for i, j in zip(The_list, CompteCree):
if i == 0 or i == 1:
C.append(j)
Abonnement = df['VoyeyAkaz\xa0status'].to_list()
A = []
for i, j in zip(The_list, Abonnement):
if i == 0 or i == 1:
A.append(j)
Data1 = len(C)
##Pour le nombre d'inscrits dans la semaine
C1 = []
for i, j in zip(The_list, CompteCree):
if i <= 7:
C1.append(j)
Data2 = len(C1)
##Pour le nombre d'inscrits dans le mois
C2 = []
for i, j in zip(The_list, CompteCree):
if i <= 30:
C2.append(j)
Data3 = len(C2)
df = pd.read_csv("UtilisateursVoyey.csv", index_col=0, parse_dates=True)
df.fillna('01/01/2200', inplace=True)
#print(df)
my_data = pd.read_csv("UtilisateursVoyey.csv",
sep=',',
header=0,
usecols=[0])
#print(my_data)
list_of_actif = my_data['Voyey\xa0ID'].to_list()
#print(list_of_actif)
Data = Counter(list_of_actif)
#print(Data)
today = datetime.today().date()
Startdate = df['Start\xa0date'].to_list()
#print(Startdate)
Abonne_list = []
for i in Startdate:
Compte = datetime.strptime(i, "%d/%m/%Y").date()
#print(Compte)
Newclients = today - Compte
Newclients = Newclients.days
Abonne_list.append(Newclients)
PrenomAbonne = df['Prénom']
PA = []
for i, j in zip(Abonne_list, PrenomAbonne):
if 0 < i <= 7:
PA.append(j)
NomAbonne = df['Nom']
NA = []
for i, j in zip(Abonne_list, NomAbonne):
if 0 < i <= 7:
NA.append(j)
PaysAbonne = df['Pays']
PaysA = []
for i, j in zip(Abonne_list, PaysAbonne):
if 0 < i <= 7:
PaysA.append(j)
EmailAbonne = df['E-mail']
EA = []
for i, j in zip(Abonne_list, EmailAbonne):
if 0 < i <= 7:
EA.append(j)
#print(EA)
Start = df['Start\xa0date']
SA = []
for i, j in zip(Abonne_list, Start):
if 0 < i <= 7:
SA.append(j)
End = df['End\xa0date']
EnA = []
for i, j in zip(Abonne_list, End):
if 0 < i <= 7:
EnA.append(j)
D = []
for i, j in zip(Abonne_list, Startdate):
if i == 1:
D.append(j)
Data = len(D)
##Pour le nombre d'abonnés dans la semaine
D1 = []
for i, j in zip(Abonne_list, Startdate):
if 0 < i <= 7:
D1.append(j)
Data4 = len(D1)
##Pour le nombre d'abonnés dans le mois
D2 = []
for i, j in zip(Abonne_list, Startdate):
if 0 < i <= 30:
D2.append(j)
Data5 = len(D2)
#print(Data5)
Datededebut = df['Start\xa0date'].to_list()
Datedefin = df['End\xa0date'].to_list()
Datededebut = [str(x) for x in Datededebut]
Datededebut = [x for x in Datededebut if x != 'nan']
Datedefin = [str(x) for x in Datedefin]
Datedefin = [x for x in Datedefin if x != 'nan']
def days_between(d1, d2):
d1 = datetime.strptime(d1, "%d/%m/%Y")
d2 = datetime.strptime(d2, "%d/%m/%Y")
return abs((d2 - d1).days)
my_list = []
for i, j in zip(Datededebut, Datedefin):
c = days_between(i, j)
my_list.append(c)
#my_list = [0 if x<32 else 1 for x in my_list]
#print(my_list)
my_list = ["Mensuel" if 0 < x < 32 else "Annuel" for x in my_list]
#print(my_list)
TypeA = []
for i, j in zip(Abonne_list, my_list):
if 0 < i <= 7:
TypeA.append(j)
st.markdown("Il y a eu **+" + str(Data1) +
"** nouveaux inscrits entre hier et aujourd'hui")
st.markdown("Il y a eu **+" + str(Data2) +
"** nouveaux inscrits au cours des 7 derniers jours")
st.markdown("Il y a eu **+" + str(Data3) +
"** nouveaux inscrits au cours des 30 derniers jours")
figure = go.Figure(data=[
go.Table(header=dict(values=[
'Prénom', 'Nom', 'Pays', 'Email', 'Statut', 'Compte Crée',
'Abonnement'
]),
cells=dict(values=[P, N, Pays1, E, S, C, A]))
])
st.plotly_chart(figure)
st.markdown("**Qui sont les nouveaux abonnés du jours?**")
st.markdown("Il y a eu **+" + str(Data) +
"** nouveaux abonnés entre hier et aujourd'hui")
st.markdown("Il y a eu **+" + str(Data4) +
"** nouveaux abonnés au cours des 7 derniers jours")
st.markdown("Il y a eu **+" + str(Data5) +
"** nouveaux abonnés au cours des 30 derniers jours")
figure1 = go.Figure(data=[
go.Table(header=dict(values=[
'Prénom', 'Nom', 'Pays', 'Email', 'Debut Abonnement',
'Fin Abonnement', 'Type Abonnement'
]),
cells=dict(values=[PA, NA, PaysA, EA, SA, EnA, TypeA]))
])
st.plotly_chart(figure1)
#fig = px.pie(df,values = my_list, names = Status,title='Abonnement')
#st.plotly_chart(fig)
return None
fig0 = go.Figure(data=[
go.Table(
header=dict(values=[
'{:,}'.format(int(us_cases_yesterday)), '{:,}'.format(
int(us_cases_hospitalized)), '{:,}'.format(int(us_cases_death))
],
fill_color='white',
align='center',
font_size=20,
height=30),
cells=dict(
values=[
[
'New Cases Yesterday',
change_text(us_cases_seven_day_trend)
], # 1st column
['Deaths Yesterday',
change_text(us_death_seven_day_trend)],
[
'Hospitalized Yesterday',
change_text(us_hospitalized_seven_day_trend)
]
], # 2nd column
fill_color='white',
font_color=[
['black', change_color(us_cases_seven_day_trend)],
['black', change_color(us_death_seven_day_trend)],
['black',
change_color(us_hospitalized_seven_day_trend)]
],
align='center')),
])
def _create_figure(self, performance_keys: dict) -> None:
n_plots = 7
w = 0.5 / (n_plots - 2)
fig = make_subplots(rows=n_plots,
cols=1,
shared_xaxes=True,
vertical_spacing=0.03,
row_heights=[0.3, w, w, w, w, w, 0.2],
specs=[
[{
"type": "candlestick"
}],
[{
"type": "scatter"
}],
[{
"type": "scatter"
}],
[{
"type": "scatter"
}],
[{
"type": "scatter"
}],
[{
"type": "scatter"
}],
[{
"type": "table"
}],
])
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.Scatter(mode='lines',
name="BB",
line=dict(color='black',
width=1.5,
dash='dot')),
row=1,
col=1)
# dash options include 'dash', 'dot', and 'dashdot'
fig.add_trace(go.Scatter(mode='lines',
name="BBUp",
line=dict(color='black', width=1,
dash='dot')),
row=1,
col=1)
fig.add_trace(go.Scatter(mode='lines',
name="BBDown",
line=dict(color='black', width=1,
dash='dot')),
row=1,
col=1)
fig.add_trace(go.Scatter(mode='lines',
name="ema10",
line=dict(color='#76FF7A',
width=1,
dash='dash')),
row=1,
col=1)
fig.add_trace(go.Scatter(mode='lines',
name="ema30",
line=dict(color='orange',
width=1,
dash='dash')),
row=1,
col=1)
fig.add_trace(go.Scatter(mode='lines',
name="ema60",
line=dict(color='red', width=1, dash='dash')),
row=1,
col=1)
fig.add_trace(go.Scatter(mode='lines',
name="ema100",
line=dict(color='#76FF7A', width=1)),
row=1,
col=1)
fig.add_trace(go.Scatter(mode='lines',
name="ema200",
line=dict(color='orange', width=1)),
row=1,
col=1)
fig.add_trace(go.Scatter(mode='lines',
name="ema300",
line=dict(color='red', width=1)),
row=1,
col=1)
for k in self.pivot_sup_res:
fig.add_trace(go.Scatter(mode='lines',
name=k,
line=dict(width=0.5, dash='dashdot')),
row=1,
col=1)
fig.add_trace(go.Bar(name='Volume',
showlegend=True,
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)
#https://plotly.com/python/multiple-axes/
### NOTE: not only the parameter "row" matters, the order of code also matters
fig.add_trace(go.Scatter(mode='lines',
name='RSI_4h',
marker={'color': 'Pink'}),
row=4,
col=1) #rsi
fig.add_trace(go.Scatter(mode='lines',
name='avg_4h',
marker={'color': 'Blue'}),
row=4,
col=1) #avg
fig.add_trace(go.Scatter(mode='lines',
name='stoRsiVol_4h',
marker={'color': 'Green'}),
row=4,
col=1) #stoRsiVol
fig.add_trace(go.Scatter(mode='lines',
name='StoRSI_4h',
marker={'color': 'Red'}),
row=4,
col=1) #storsi
fig.add_trace(go.Scatter(mode='lines',
name='RSI',
marker={'color': 'Pink'}),
row=5,
col=1) #rsi
fig.add_trace(go.Scatter(mode='lines',
name='avg',
marker={'color': 'Blue'}),
row=5,
col=1) #avg
fig.add_trace(go.Scatter(mode='lines',
name='stoRsiVol',
marker={'color': 'Green'}),
row=5,
col=1) #stoRsiVol
fig.add_trace(go.Scatter(mode='lines',
name='StoRSI',
marker={'color': 'Red'}),
row=5,
col=1) #storsi
fig.add_trace(go.Scatter(mode='lines',
name='RSI_x2',
marker={'color': 'Pink'}),
row=6,
col=1) #rsi
fig.add_trace(go.Scatter(mode='lines',
name='avg_x2',
marker={'color': 'Blue'}),
row=6,
col=1) #avg
fig.add_trace(go.Scatter(mode='lines',
name='stoRsiVol_x2',
marker={'color': 'Green'}),
row=6,
col=1) #stoRsiVol
fig.add_trace(go.Scatter(mode='lines',
name='StoRSI_x2',
marker={'color': 'Red'}),
row=6,
col=1) #storsi
fig.add_trace(
go.Table(
# header=dict(
# values=["open", "close"],
# font=dict(size=10),
# align="left"
# )
#,
# cells=dict(
# values=[df[k].tolist() for k in price.columns[1:]],
# align = "left")
),
row=7,
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='4H', row=4)
fig.update_xaxes(title_text='6H', row=5)
fig.update_xaxes(title_text='8H', row=6)
fig.update_xaxes(title_standoff=7, title_font=dict(size=12))
self.fig = go.FigureWidget(fig)
self._price_chart = self.fig.data[0]
self._bb_chart = self.fig.data[1]
self._bbUp_chart = self.fig.data[2]
self._bbDown_chart = self.fig.data[3]
self._ema10_chart = self.fig.data[4]
self._ema30_chart = self.fig.data[5]
self._ema60_chart = self.fig.data[6]
self._ema100_chart = self.fig.data[7]
self._ema200_chart = self.fig.data[8]
self._ema300_chart = self.fig.data[9]
self._pivot_sup_res_chart = self.fig.data[10]
counter = 10 + len(self.pivot_sup_res)
self._volume_chart = self.fig.data[counter]
self._performance_chart = self.fig.data[counter + 1]
counter = counter + 1 + len(performance_keys)
#self._net_worth_chart = self.fig.data[counter]
# self._rsi_chart = self.fig.data[counter+1]
# self._avg_chart = self.fig.data[counter+2]
# self._stoRsiVol_chart = self.fig.data[counter+3]
# self._stoRsi_chart = self.fig.data[counter+4]
# self._rsi_4h_chart = self.fig.data[counter+5]
# self._avg_4h_chart = self.fig.data[counter+6]
# self._stoRsiVol_4h_chart = self.fig.data[counter+7]
# self._stoRsi_4h_chart = self.fig.data[counter+8]
# self._metric_table = self.fig.data[counter+9]
self._rsi_4h_chart = self.fig.data[counter]
self._avg_4h_chart = self.fig.data[counter + 1]
self._stoRsiVol_4h_chart = self.fig.data[counter + 2]
self._stoRsi_4h_chart = self.fig.data[counter + 3]
self._rsi_chart = self.fig.data[counter + 4]
self._avg_chart = self.fig.data[counter + 5]
self._stoRsiVol_chart = self.fig.data[counter + 6]
self._stoRsi_chart = self.fig.data[counter + 7]
self._rsi_x2_chart = self.fig.data[counter + 8]
self._avg_x2_chart = self.fig.data[counter + 9]
self._stoRsiVol_x2_chart = self.fig.data[counter + 10]
self._stoRsi_x2_chart = self.fig.data[counter + 11]
self._metric_table = self.fig.data[counter + 12]
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 plot_table_color(col_labels, values, title, font_size=12):
color_list = ['paleturquoise']
light_color = 'rgb(190, 190, 245)'
dark_color = 'rgb(150, 125, 175)'
for i in range(1, len(values)):
vals = values[i]
if isinstance(vals[0], np.int64) or isinstance(vals[0], np.float64):
vals = np.array([int(v * 10) for v in vals])
colors = np.array(
n_colors(light_color,
dark_color,
max(vals) - min(vals) + 5,
colortype='rgb'))
color_list.append(colors[vals - min(vals)])
elif isinstance(vals[0], str):
time_units = vals[0].split(':')
if len(time_units) == 2:
vals = [pd.Timedelta('00:' + x).seconds for x in vals]
if max(vals) - min(vals) == 0:
color_list.append(light_color)
else:
colors = np.array(
n_colors(light_color,
dark_color,
max(vals) - min(vals) + 5,
colortype='rgb'))
color_list.append(colors[[(x - min(vals)) for x in vals]])
elif len(time_units) == 3:
vals = [pd.Timedelta(x).seconds for x in vals]
if max(vals) - min(vals) == 0:
color_list.append(light_color)
else:
colors = np.array(
n_colors(light_color,
dark_color,
max(vals) - min(vals) + 5,
colortype='rgb'))
color_list.append(colors[[(x - min(vals)) for x in vals]])
else:
color_list.append('white')
else:
color_list.append('white')
print(color_list)
fig = go.Figure(data=[
go.Table(
# columnorder = [1,2,3],
# columnwidth = [80,400],
header=dict(values=col_labels,
line_color='darkslategray',
fill_color='royalblue',
align=['center', 'center'],
font=dict(color='white', size=font_size),
height=40),
cells=dict(
values=values,
line_color='darkslategray',
# fill=dict(color=['paleturquoise', 'white']),
fill_color=color_list,
align=['left', 'center'],
font_size=font_size,
height=30))
])
fig.update_layout(
title=title,
title_x=0.5,
font=dict(family="Times New Roman", size=20, color="Black"),
)
return fig
def topics(df1, english_only=True):
'''
Takes a dataframe with tweets and extracts topics. Prints top 10 topics and plots four wordclouds for the top four topics.
Parameters:
-df: a preprocessed dataframe with a 'tweets' column
-english_only = filters non-english tweets if True, defaults to True
'''
from nltk import download
download('wordnet')
from nltk.stem import WordNetLemmatizer
from sklearn.decomposition import LatentDirichletAllocation
import matplotlib.pyplot as plt
import pandas as pd
from sklearn.feature_extraction.text import TfidfVectorizer, CountVectorizer
from wordcloud import WordCloud, ImageColorGenerator, STOPWORDS
import plotly.graph_objects as go
from pandas import DataFrame
from textblob import TextBlob
# Storing the entire text in a list
text = list(df1.tweet.values)
# There is no built-in lemmatizer in the Sklearn vectorizer so we extend the CountVectorizer class by overwriting the "build_analyzer" method as follows to add a lemmatizer:
lemm = WordNetLemmatizer()
class LemmaCountVectorizer(CountVectorizer):
def build_analyzer(self):
analyzer = super(LemmaCountVectorizer, self).build_analyzer()
return lambda doc: (lemm.lemmatize(w) for w in analyzer(doc))
# Calling our overwritten Count vectorizer on text
tf_vectorizer = LemmaCountVectorizer(max_df=0.95,
min_df=2,
stop_words='english',
decode_error='ignore')
tf = tf_vectorizer.fit_transform(text)
# create an LDA instance through the Sklearn's LatentDirichletAllocation function
lda = LatentDirichletAllocation(n_components=11,
max_iter=5,
learning_method='online',
learning_offset=50.,
random_state=0)
# fit LDA model
lda.fit(tf)
# Define helper function to print top words
topics = []
def print_top_words(model, feature_names, n_top_words):
for index, topic in enumerate(model.components_):
message = " ".join([(feature_names[i] + ',')
for i in topic.argsort()[:-n_top_words - 1:-1]
])
message = message[0:(len(message) - 1)]
topics.append(message)
# print top words for each topic
n_top_words = 20
print("\nTopics in LDA model: ")
tf_feature_names = tf_vectorizer.get_feature_names()
print_top_words(lda, tf_feature_names, n_top_words)
# get sentiments for each topic
def fetch_sentiment_using_textblob(text):
sentiment = []
for i in text:
analysis = TextBlob(i)
# set sentiment
if analysis.sentiment.polarity >= 0:
sentiment.append('positive')
elif analysis.sentiment.polarity == 0:
sentiment.append('neutral')
else:
sentiment.append('negative')
return sentiment
topics_df = DataFrame(topics, columns=['topic'])
sentiments = []
for topic in topics_df['topic']:
sentiments.append(fetch_sentiment_using_textblob(topics_df))
# create table for topics
fig = go.Figure(data=[
go.Table(header=dict(values=[
'Topics (by rank)', 'Top Words in Topic', 'Topic Sentiment'
]),
cells=dict(
values=[[('Topic ' + str(i))
for i in range(1, 11)], topics, sentiments]))
])
fig.update_layout(width=700, height=700)
#fig.show()
# Word Cloud visualizations of the topics
first_topic = lda.components_[0]
second_topic = lda.components_[1]
third_topic = lda.components_[2]
fourth_topic = lda.components_[3]
first_topic_words = [
tf_feature_names[i] for i in first_topic.argsort()[:-50 - 1:-1]
]
second_topic_words = [
tf_feature_names[i] for i in second_topic.argsort()[:-50 - 1:-1]
]
third_topic_words = [
tf_feature_names[i] for i in third_topic.argsort()[:-50 - 1:-1]
]
fourth_topic_words = [
tf_feature_names[i] for i in fourth_topic.argsort()[:-50 - 1:-1]
]
for i, topic in enumerate([
first_topic_words, second_topic_words, third_topic_words,
fourth_topic_words
],
start=1):
cloud = WordCloud(stopwords=STOPWORDS,
background_color='black',
width=2500,
height=1800).generate(" ".join(topic))
plt.imshow(cloud)
plt.title("Topic " + str(i))
plt.axis('off')
# plt.savefig('topic' + '.png')
#plt.show()
return fig
def comparareClientsTransaction(number, allClients):
print(number)
print('>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>')
for cli in allClients:
temp = {}
temp['RESOLVED']=0.0
temp['DISCARDED']=0.0
temp['PENDING_COLLATERAL']=0.0
readed_data[cli]=temp
with open("../processed_data.csv", 'r') as csvfile:
csvreader = csv.reader(csvfile)
fields=next(csvreader)
#test=0
for row in csvreader:
readed_data[row[1]][row[4]]=readed_data[row[1]][row[4]]+1.0
for cli in readed_data.keys():
total = 0.0
for ty in readed_data[cli].keys():
total=total+readed_data[cli][ty]
for ty in readed_data[cli].keys():
if total >0:
readed_data[cli][ty]=round((readed_data[cli][ty]*100)/total, 3)
print(readed_data)
sorted_clients = {}
x_bar = []
y_bar_resolved=[]
y_bar_discarded=[]
y_bar_pendingcollateral=[]
for cli in readed_data.keys():
sorted_clients[cli]=-1*readed_data[cli]['RESOLVED']
s_clients={k: -1*v for k, v in sorted(sorted_clients.items(), key=lambda item: item[1])}
print(s_clients)
i=0
for cli in s_clients:
x_bar.append(cli)
y_bar_resolved.append(readed_data[cli]['RESOLVED'])
y_bar_discarded.append(readed_data[cli]['DISCARDED'])
y_bar_pendingcollateral.append(readed_data[cli]['PENDING_COLLATERAL'])
i=i+1
print(i)
if i == int(number):
break
print('.................................................................................')
print(x_bar)
print(y_bar_resolved)
print(y_bar_discarded)
print(y_bar_pendingcollateral)
table_col=['Clients', 'Resolved Payments', 'Pending Collateral', 'Discarded']
table_row=[]
table_row.append(x_bar)
table_row.append(y_bar_resolved)
table_row.append(y_bar_pendingcollateral)
table_row.append(y_bar_discarded)
fig1=go.Figure()
fig1 = make_subplots(rows=2, cols=1, vertical_spacing=0.09,specs=[ [{"type": "table"}],[{"type": "bar"}] ] )
fig1.add_trace(go.Table(header=dict(values=table_col,font=dict(size=10),align="left"), cells=dict(values=table_row, height=40,align="left")), row=1, col=1)
fig1.add_trace(go.Bar(x=x_bar, y=y_bar_resolved, name='Resolved', hovertext='Resolved Payments %',text=y_bar_resolved, textposition='auto'), row=2, col=1)
fig1.add_trace(go.Bar(x=x_bar, y=y_bar_pendingcollateral, name='Pending Col..',hovertext='Pending Collateral %',text=y_bar_pendingcollateral, textposition='auto'), row=2, col=1)
fig1.add_trace(go.Bar(x=x_bar, y=y_bar_discarded, name='Discarded',hovertext='Discarded %',text=y_bar_discarded, textposition='auto'), row=2, col=1)
pio.write_html(fig1, file='templates/topNClientsGraph.html')
fig.show()
# Donald Trump
# Most positive replies
most_positive1 = df_subset_trump[df_subset_trump.Sentiment_Polarity ==
1].text.head()
pos_txt1 = list(most_positive1)
pos1 = df_subset_trump[df_subset_trump.Sentiment_Polarity ==
1].Sentiment_Polarity.head()
pos_pol1 = list(pos1)
fig = go.Figure(data=[
go.Table(
columnorder=[1, 2],
columnwidth=[50, 400],
header=dict(
values=['Polarity', 'Most Positive Responses on Trump\'s Handle'],
fill_color='paleturquoise',
align='left'),
cells=dict(
values=[pos_pol1, pos_txt1], fill_color='lavender', align='left'))
])
fig.show()
# Most Negative Responses
most_negative1 = df_subset_trump[df_subset_trump.Sentiment_Polarity ==
-1].text.head()
neg_txt1 = list(most_negative1)
neg1 = df_subset_trump[df_subset_trump.Sentiment_Polarity ==
-1].Sentiment_Polarity.head()
neg_pol1 = list(neg1)
}], [{
"type": "sunburst"
}]],
)
fig.add_trace(
go.Table(
header=dict(
values=[
"Descrizione Amministrazione",
"Descrizione Programma",
"Descrizione Azione",
] + ["Previsioni iniziali competenza"],
font=dict(size=10),
align="left",
),
cells=dict(
values=[
bilancio_data[k].tolist() for k in [
"Descrizione Amministrazione",
"Descrizione Programma",
"Descrizione Azione",
] + ["Previsioni iniziali competenza"]
],
align="left",
),
),
row=2,
col=1,
)
sb = px.sunburst(
def updatefigure3(valued, valuep):
previous = int(valuep)
date = valued
df_recap = GetData.get_recap_by_country(date, previous=previous)
fill_color_H2 = 'lightgray'
line_color_H2 = 'lightgray'
font_color_H2 = [['black', 'red']]
#USA
us_deaths = f'{int(df_recap["Deaths"][df_recap["Country/Region"]=="US"]):,}'
us_deaths = "<b>{0}</b>".format(us_deaths)
us_casesp = f'{int(df_recap["Cases (+)"][df_recap["Country/Region"]=="US"]):,}'
us_deathsp = f'{int(df_recap["Deaths (+)"][df_recap["Country/Region"]=="US"]):,}'
us_casesp = "<b>(+{0})</b>".format(us_casesp)
us_deathsp = "<b>(+{0})</b>".format(us_deathsp)
#France
france_deaths = f'{int(df_recap["Deaths"][df_recap["Country/Region"]=="France"]):,}'
france_deaths = "<b>{0}</b>".format(france_deaths)
france_deathsp = f'{int(df_recap["Deaths (+)"][df_recap["Country/Region"]=="France"]):,}'
france_deathsp = "<b>(+{0})</b>".format(france_deathsp)
#Italy
italy_deaths = f'{int(df_recap["Deaths"][df_recap["Country/Region"]=="Italy"]):,}'
italy_deaths = "<b>{0}</b>".format(italy_deaths)
italy_deathsp = f'{int(df_recap["Deaths (+)"][df_recap["Country/Region"]=="Italy"]):,}'
italy_deathsp = "<b>(+{0})</b>".format(italy_deathsp)
#Germany
germany_deaths = f'{int(df_recap["Deaths"][df_recap["Country/Region"]=="Germany"]):,}'
germany_deaths = "<b>{0}</b>".format(germany_deaths)
germany_deathsp = f'{int(df_recap["Deaths (+)"][df_recap["Country/Region"]=="Germany"]):,}'
germany_deathsp = "<b>(+{0})</b>".format(germany_deathsp)
#China
china_deaths = f'{int(df_recap["Deaths"][df_recap["Country/Region"]=="China"]):,}'
china_deaths = "<b>{0}</b>".format(china_deaths)
china_deathsp = f'{int(df_recap["Deaths (+)"][df_recap["Country/Region"]=="China"]):,}'
china_deathsp = "<b>(+{0})</b>".format(china_deathsp)
#Spain
spain_deaths = f'{int(df_recap["Deaths"][df_recap["Country/Region"]=="Spain"]):,}'
spain_deaths = "<b>{0}</b>".format(spain_deaths)
spain_deathsp = f'{int(df_recap["Deaths (+)"][df_recap["Country/Region"]=="Spain"]):,}'
spain_deathsp = "<b>(+{0})</b>".format(spain_deathsp)
#Iran
iran_deaths = f'{int(df_recap["Deaths"][df_recap["Country/Region"]=="Iran"]):,}'
iran_deaths = "<b>{0}</b>".format(iran_deaths)
iran_deathsp = f'{int(df_recap["Deaths (+)"][df_recap["Country/Region"]=="Iran"]):,}'
iran_deathsp = "<b>(+{0})</b>".format(iran_deathsp)
values_H4=[[china_deaths,china_deathsp],[france_deaths,france_deathsp],\
[germany_deaths,germany_deathsp],[us_deaths,us_deathsp],\
[spain_deaths,spain_deathsp], [iran_deaths,iran_deathsp],\
[italy_deaths,italy_deathsp]]
fig_H4= go.Figure(data=[go.Table(
header=dict(values=["China","France", "Germany"\
,"US","Spain","Iran"\
,"Italy"]
,
line_color=line_color_H2,fill_color=fill_color_H2,
align='center',font=dict(color='black', size=10)
),
cells=dict(
line_color=line_color_H2,fill_color=fill_color_H2,font_color=font_color_H2,
values=values_H4, font_size=13
))
])
fig_H4.update_layout(autosize=False,
width=1000,
height=170,
margin=dict(l=300, r=20, b=0, t=40, pad=20),
title_text="<b>DEATHS</b>",
title_x=0.63,
title_font_color='black')
return fig_H4
def updatefigure3(valued, valuep):
previous = int(valuep)
date = valued
df_recap = GetData.get_recap_by_country(date, previous=previous)
fill_color_H2 = 'lightgray'
line_color_H2 = 'lightgray'
font_color_H2 = [['black', 'red']]
font_size_H2 = [12, 11, 11, 11, 11, 11, 11]
columns_ = [
"Country", "New Cases", "Total Cases", "New Deaths", "Total Deaths",
"Fatality", "Recovered"
]
columns_ = ['<b>{0}</b>'.format(i) for i in columns_]
df_H5 = pd.DataFrame(columns=[
"Country", "New Cases", "Total Cases", "New Deaths", "Total Deaths",
"Fatality", "Recovered"
])
df_H5["Country"] = x = [
'<b>{0}</b>'.format(i) for i in df_recap["Country/Region"]
]
df_H5["Total Cases"] = df_recap["Cases"]
df_H5["Total Deaths"] = df_recap["Deaths"]
df_H5["Fatality"] = df_H5["Total Deaths"] / df_H5["Total Cases"]
df_H5["Total Deaths"] = df_recap["Deaths"]
df_H5["Recovered"] = df_recap["Recovered"]
df_H5["New Cases"] = [f'{i:,}' for i in df_recap["Cases (+)"]]
df_H5["New Cases"] = ["(+{0})".format(str(i)) for i in df_H5["New Cases"]]
df_H5["New Deaths"] = [f'{i:,}' for i in df_recap['Deaths (+)']]
df_H5["New Deaths"] = [
"(+{0})".format(str(i)) for i in df_H5["New Deaths"]
]
df_H5["Fatality"] = ["{:.2%}".format(i) for i in df_H5["Fatality"]]
df_H5["Recovered"] = [f'{i:,}' for i in df_H5["Recovered"]]
df_H5["Total Cases"] = [f'{i:,}' for i in df_H5["Total Cases"]]
df_H5["Total Deaths"] = [f'{i:,}' for i in df_H5["Total Deaths"]]
font_color_H5 = ['black', 'red', 'black', 'red', 'black', 'red', 'black']
fig_H5 = go.Figure(go.Table(
header=dict(values=list(columns_),
align ='center', font=dict(color='black',size=12),
line_color=line_color_H2,
fill_color=fill_color_H2),
cells=dict(values=[df_H5.Country, df_H5["New Cases"],df_H5["Total Cases"]\
, df_H5["New Deaths"], df_H5["Total Deaths"],\
df_H5.Fatality, df_H5.Recovered],
font_size=font_size_H2,font_color=font_color_H5,
line_color=line_color_H2,fill_color=fill_color_H2)))
fig_H5.update_layout(autosize=False,
width=1000,
height=400,
margin=dict(l=300, r=20, b=100, t=50, pad=400),
title_text="<b>BY COUNTRY</b>",
title_x=0.63,
title_font_color='black')
return fig_H5
def updatefigure1(valued, valuep):
previous = int(valuep)
date = valued
df_recap = GetData.get_recap_by_country(date, previous=previous)
#Récupération des cas confirmés
df_confirmed = GetData.get_world('confirmed')
confirmed = df_confirmed.iloc[:, 5:].sum(axis=1).sum(axis=0)
confirmedp = df_recap['Cases (+)'].sum(axis=0)
#Récupération des cas morts
df_deaths = GetData.get_world('deaths')
deaths = df_deaths.iloc[:, 5:].sum(axis=1).sum(axis=0)
deathsp = df_recap['Deaths (+)'].sum(axis=0)
#Récupération des cas guéris
df_recovered = GetData.get_world('recovered')
recovered = df_recovered.iloc[:, 5:].sum(axis=1).sum(axis=0)
recoveredp = df_recap['Recovered (+)'].sum(axis=0)
confirmed = f'{confirmed:,}'
deaths = f'{deaths:,}'
recovered = f'{recovered:,}'
confirmedp = f'{confirmedp:,}'
deathsp = f'{deathsp:,}'
recoveredp = f'{recoveredp:,}'
a = "<b>{0}</b>".format(confirmed)
b = "<b>{0}</b>".format(deaths)
c = "<b>{0}</b>".format(recovered)
e = "<b>(+{0})</b>".format(confirmedp)
f = "<b>(+{0})</b>".format(deathsp)
g = "<b>(+{0})</b>".format(recoveredp)
#CSS
fill_color_H2 = 'lightgray'
line_color_H2 = 'lightgray'
font_color_H2 = [['black', 'red']]
font_size_H2 = [15]
#layout = go.Layout( autosize=True, **margin={'l': 0, 'r': 0, 't': 20, 'b': 0}**)
fig_H2 = go.Figure(data=[
go.Table(header=dict(values=["Confirmed Cases", "Deaths", "Recovered"],
line_color=line_color_H2,
fill_color=fill_color_H2,
align='center',
font=dict(color='black', size=10)),
cells=dict(values=[[a, e], [b, f], [c, g]],
align='center',
line_color=line_color_H2,
fill_color=fill_color_H2,
font_color=font_color_H2,
font_size=font_size_H2))
])
fig_H2.update_layout(autosize=False,
width=500,
height=170,
margin=dict(l=20, r=20, b=20, t=50, pad=10),
title_text="<b>WORLD</b>",
title_x=0.5,
title_font_color='black')
return fig_H2
def update_tabble(n):
loop = contract.functions.getTransID().call()
limit = loop + 1
dfall = pd.DataFrame() # this is for all the rice info
for i in range(1, int(limit)):
stId = i
manu = contract.functions.getManu(int(i)).call()
bran = contract.functions.getBrand(int(i)).call()
area = contract.functions.getArea(int(i)).call()
stat = contract.functions.getStatus(
int(i)).call() # Status (Delivered / Recieved)
stRe = contract.functions.getStatusRecieved(
int(i)).call() # StatusRecieved (Damaged / Stolen / Complete)
stWe = contract.functions.getStatusWeight(
int(i)).call() # StatusWeight (if stRe = Complete : stWe = 0)
fuldate = str(contract.functions.getDate(int(i)).call())
year = contract.functions.getYear(int(i)).call()
mont = contract.functions.getMonth(int(i)).call()
day = contract.functions.getDay(int(i)).call()
wght = contract.functions.getWeight(int(i)).call()
pric = contract.functions.getPrice(int(i)).call()
user = contract.functions.getUser(int(i)).call()
rewg = wght - stWe # This is for the remaining weight
s_datetime = datetime.datetime.strptime(fuldate, '%Y%m%d')
Rice = {
'Manufacturer': [manu],
'Brand': [bran],
'Area': [area],
'Status': [stat],
'StatusRecieved': [stRe],
'StatusWeight': [stWe],
'Date': [s_datetime],
'Year': [year],
'Month': [mont],
'Day': [day],
'Weight': [wght],
'Price': [pric],
'RemainingWeight': [rewg],
'User': [user]
}
dfnew = pd.DataFrame(Rice,
columns=[
'Manufacturer', 'Brand', 'Area', 'Status',
'StatusRecieved', 'StatusWeight', 'Date',
'Year', 'Month', 'Day', 'Weight', 'Price',
'RemainingWeight', 'User'
])
dfall = dfall.append(dfnew, ignore_index=True)
try:
tablefig = go.Figure(data=[
go.Table(
header=dict(values=[
'<b>Date</b>', '<b>Area</b>', '<b>Manufacturer</b>',
'<b>Brand</b>', '<b>Status</b>',
'<b>Damaged, Stolen, Complete</b>', '<b>Weight(kg)</b>',
'<b>Weight of Damage</b>',
'<b>Usable/Sellable Rice(kg)</b>', '<b>Price per kg</b>',
'<b>Encoder</b>'
],
line_color='darkslategray',
align=['center'],
font=dict(color='black', size=12)),
cells=dict(
values=[
dfall.Date, dfall.Area, dfall.Manufacturer,
dfall.Brand, dfall.Status, dfall.StatusRecieved,
dfall.Weight, dfall.StatusWeight,
dfall.RemainingWeight, dfall.Price, dfall.User
],
line_color='darkslategray',
align=['center'],
font=dict(color='darkslategray', size=12),
),
)
])
print("Updating Table...")
except:
tablefig = go.Figure(data=[
go.Table(
header=dict(values=[
'<b>Date</b>', '<b>Area</b>', '<b>Manufacturer</b>',
'<b>Brand</b>', '<b>Status</b>',
'<b>Damaged, Stolen, Complete</b>', '<b>Weight(kg)</b>',
'<b>Weight of Damage</b>',
'<b>Usable/Sellable Rice(kg)</b>', '<b>Price per kg</b>',
'<b>Details</b>'
],
line_color='darkslategray',
align=['center'],
font=dict(color='black', size=12)),
cells=dict(
values=[
None, None, None, None, None, None, None, None, None,
None, None
],
line_color='darkslategray',
align=['center'],
font=dict(color='darkslategray', size=12),
),
),
])
return tablefig
groups = [defensive_group, aggressive_group, mixed_group]
names = ['defensive', 'aggressive', 'mixed']
results = invsim.return_and_vol_on_portfolios(groups, names)
header = ['Index', 'Defensive', 'Aggressive', 'Mixed']
fig = go.Figure(data=[
go.Table(header=dict(values=header,
fill_color='#4575b4',
align='center',
font=dict(color='white', size=23),
height=50),
cells=dict(values=[
results.index, results.defensive, results.aggressive,
results.mixed
],
fill_color='#e0f3f8',
align='center',
font=dict(color='#999999', size=20),
height=40))
])
st.plotly_chart(fig, use_container_width=True)
#fig, ax = plt.subplots(figsize=(8, 2))
#ax.xaxis.set_visible(False)
#ax.yaxis.set_visible(False)
#ax.set_frame_on(False)
#tabla = pd.plotting.table(ax, results, loc='upper right', colWidths=[0.2]*len(results.columns))
def calculate_temperatures(p90, p50, p10,
md, kb, gl, clicks, mast, name,
colourp90, colourp50, colourp10, depth_type, region):
tvdss = md - (kb - gl)
tvdbml = md - (kb + gl)
def depth_listing(value):
value_list = []
if value % 500 == 0:
for i in range(0, value + 500, 500):
value_list.append(i)
elif value % 500 != 0:
for i in range(0, (value - (value % 500)) + 500, 500):
value_list.append(i)
value_list.append(value)
for i in value_list:
if value == md:
md_predict.append(i)
elif value == tvdss:
tvdss_predict.append(i)
elif value == tvdbml:
tvd_predict.append(i)
if value == md:
return md_predict
elif value == tvdss:
return tvdss_predict
elif value == tvdbml:
return tvd_predict
def calculate():
if region == "Offshore":
for i in range(len(tvd_predict)):
t90 = ((tvd_predict[i] * p90) / 1000) + mast
t50 = ((tvd_predict[i] * p50) / 1000) + mast
t10 = ((tvd_predict[i] * p10) / 1000) + mast
temp_predict90.append(t90)
temp_predict50.append(t50)
temp_predict10.append(t10)
elif region == "Onshore":
for i in range(len(tvdss_predict)):
t90 = ((tvdss_predict[i] * p90) / 1000) + mast
t50 = ((tvdss_predict[i] * p50) / 1000) + mast
t10 = ((tvdss_predict[i] * p10) / 1000) + mast
temp_predict90.append(t90)
temp_predict50.append(t50)
temp_predict10.append(t10)
return temp_predict90, temp_predict50, temp_predict10
if clicks == 1:
depth_listing(md)
depth_listing(tvdss)
depth_listing(tvdbml)
calculate()
elif clicks > 1:
md_predict.clear ()
tvdss_predict.clear ()
tvd_predict.clear()
temp_predict90.clear()
temp_predict50.clear()
temp_predict10.clear()
depth_listing(md)
depth_listing(tvdss)
depth_listing(tvdbml)
calculate()
if region == "Onshore":
fig1 = go.Figure(data=[go.Table(header=dict(values=["TVDgl (m.)", 'P90', 'P50', 'P10']),
cells=dict(values=[tvdss_predict, temp_predict90, temp_predict50, temp_predict10]))])
elif region == "Offshore":
fig1 = go.Figure(data=[go.Table(header=dict(values=["TVDbml (m.)", 'P90', 'P50', 'P10']),
cells=dict(values=[tvd_predict, temp_predict90, temp_predict50, temp_predict10]))])
fig2 = go.Figure()
if depth_type == "TVDbml (m.)":
fig2.add_trace(go.Scatter(x=temp_predict90, y=tvd_predict, name="P90", line_color=colourp90))
fig2.add_trace(go.Scatter(x=temp_predict50, y=tvd_predict, name="P50", line_color=colourp50))
fig2.add_trace(go.Scatter(x=temp_predict10, y=tvd_predict, name="P10", line_color=colourp10))
fig2.update_yaxes(title="TVDbml (m.)")
elif depth_type == "TVDkb (m.)":
fig2.add_trace(go.Scatter(x=temp_predict90, y=md_predict, name="P90", line_color=colourp90))
fig2.add_trace(go.Scatter(x=temp_predict50, y=md_predict, name="P50", line_color=colourp50))
fig2.add_trace(go.Scatter(x=temp_predict10, y=md_predict, name="P10", line_color=colourp10))
fig2.update_yaxes(title="TVDkb (m.)")
elif depth_type == "TVDgl (m.)":
fig2.add_trace(go.Scatter(x=temp_predict90, y=tvdss_predict, name="P90", line_color=colourp90))
fig2.add_trace(go.Scatter(x=temp_predict50, y=tvdss_predict, name="P50", line_color=colourp50))
fig2.add_trace(go.Scatter(x=temp_predict10, y=tvdss_predict, name="P10", line_color=colourp10))
fig2.update_yaxes(title="TVDgl (m.)")
fig2.update_yaxes(autorange="reversed")
fig2.update_layout(title="Temperature prediction graph of {}".format(name),
xaxis_title="Temperatures (C)", legend_title="Legend")
return fig1, fig2
def bar_graph():
"""
def bar_graph() is a function that produces Figure 1
where a comparison of success(blue color) vs failure (orange color)
of drone flights are plotted in each 30 second interval.
"""
result = {}
# read excel file where all the data related to drone flights are stored
df = pd.read_excel("inputFiles/Battery_Aging.xlsx")
# read the column of total flight times
times = (df["Total flight time(s)"])
# going through the number of rows that have total flight time in seconds
for i in range(len(times)):
# find the interval assignment (interval 1 - 1.5 , 1.5 - 2, 2.5 - 3]
intervalNum = (int(times[i] / 30)) * 0.5
if intervalNum < 1:
continue
# if intervalNum not in dictionary
# Failed flight times are indicated through '0' & success through '1'
if intervalNum not in result:
if df['Fail'][i] == 0:
result[intervalNum] = (0, 1)
elif df['Fail'][i] == 1:
result[intervalNum] = (1, 0)
# store total Failures in 1st index, total Successes in 0 index
else:
numFailures = result[intervalNum][1]
numSuccesses = result[intervalNum][0]
if df['Fail'][i] == 0:
result[intervalNum] = (numSuccesses, numFailures + 1)
elif df['Fail'][i] == 1:
result[intervalNum] = (numSuccesses + 1, numFailures)
# created 3 arrays to store flight times, number of success, and number of failures from tuple
times = []
successes = []
failures = []
minutes = list(result.keys())
minutes.sort()
# append values related to eachc category in the array
for key in minutes:
times.append(key)
successes.append(result[key][0])
failures.append(result[key][1])
# plot bar graph
plt.xlabel("Total Flight time(m)")
plt.ylabel("Total Number of Flights")
plt.title("Time vs Flight Success")
plt.xticks(np.arange(1, 10, 0.5))
f = plt.figure(1)
barWidth = 0.5
plt.bar(times, successes, edgecolor="white", width=barWidth)
plt.bar(times,
failures,
edgecolor="white",
bottom=successes,
width=barWidth)
f.show()
""""
created a table correlating to bar graph
to quantify the number of successes vs failures
for better understanding of why there were more failed flights in certain time intervals
"""
interval = [
" 0 - 1.0 ", " 1.0 - 1.5 ", " 1.5 - 2.0 ", " 2.0 - 2.5 ",
" 2.5 - 3.0 ", " 3.0 - 3.5 ", " 3.5 - 4.0 ", " 4.0 - 4.5 ",
" 4.5 - 5.0 ", " 5.0 - 5.5 ", " 5.5 - 6.0 ", " 6.0 - 6.5 ",
" 6.5 - 7.0 ", " 7.0 - 7.5 ", " 7.5 - 9.0 "
]
fig = go.Figure(data=[
go.Table(header=dict(
values=['Interval Time', 'Flight Successes', 'Flight Failures']),
cells=dict(values=[interval, successes, failures]))
])
fig.show()
def post_drill_analysis (add, md1, md2, md3, md4, md5, md6,
bht1, bht2, bht3, bht4, bht5, bht6, kb, gl, mast, name,
colouraapg, colourharr, region):
m_list = [md1, md2, md3, md4, md5, md6]
b_list = [bht1, bht2, bht3, bht4, bht5, bht6]
def calculation ():
for i in range (len (m_list)):
if m_list[i] > 0:
md_list.append (m_list[i])
for j in range(len(b_list)):
if b_list[j] > 0:
bht_list.append(b_list[j])
for i in range(len(md_list)):
if region == "Onshore":
tvd = md_list[i] - (kb - gl)
tvd_list.append(tvd)
elif region == "Offshore":
tvd = md_list[i] - (kb + gl)
tvdss_list.append(tvd)
if region == "Onshore":
for i in range(len(tvd_list)):
bht = ((1.878 / 1000 * tvd_list[i]) + (8.476e-07 * (tvd_list[i] ** 2)) - (5.091e-11 * (tvd_list[i] ** 3)) - (1.681e-14 * (tvd_list[i] ** 4))) + bht_list[i]
c = (bht - 32) / 1.8
bht_harr = -(math.exp(((tvd_list[i] ** 2) * -6))) + (0.01826842109 * tvd_list[i]) - 16.51213476 + bht_list[i]
c_harr = (bht_harr - 32) / 1.8
aapg_f.append(bht)
aapg_c.append(c)
harr_f.append(bht_harr)
harr_c.append(c_harr)
elif region == "Offshore":
for i in range(len(tvdss_list)):
bht = ((1.878 / 1000 * tvdss_list[i]) + (8.476e-07 * (tvdss_list[i] ** 2)) - (5.091e-11 * (tvdss_list[i] ** 3)) - (1.681e-14 * (tvdss_list[i] ** 4))) + bht_list[i]
c = (bht - 32) / 1.8
bht_harr = -(math.exp(((tvdss_list[i] ** 2) * -6))) + (0.01826842109 * tvdss_list[i]) - 16.51213476 + bht_list[i]
c_harr = (bht_harr - 32) / 1.8
aapg_f.append(bht)
aapg_c.append(c)
harr_f.append(bht_harr)
harr_c.append(c_harr)
md_list.insert (0, 0)
tvd_list.insert(0, 0)
tvdss_list.insert(0, 0)
aapg_c.insert(0, mast)
harr_c.insert(0, mast)
if region == "Onshore":
for i in range (len(aapg_c)):
grad1 = ((aapg_c[i]-aapg_c[i-1])/(tvd_list[i]-tvd_list[i-1]))*1000
grad_aapg.append (grad1)
grad2 = ((harr_c[i]-harr_c[i-1])/(tvd_list[i]-tvd_list[i-1]))*1000
grad_harr.append (grad2)
if region == "Offshore":
for i in range(len(aapg_c)):
grad1 = ((aapg_c[i] - aapg_c[i - 1]) / (tvdss_list[i] - tvdss_list[i - 1])) * 1000
grad_aapg.append(grad1)
grad2 = ((harr_c[i] - harr_c[i - 1]) / (tvdss_list[i] - tvdss_list[i - 1])) * 1000
grad_harr.append(grad2)
return md_list, tvd_list, tvdss_list, aapg_c, harr_c, grad_aapg, grad_harr
if add == 1:
calculation()
elif add > 1:
md_list.clear ()
bht_list.clear ()
tvd_list.clear ()
tvdss_list.clear()
aapg_f.clear()
aapg_c.clear()
harr_f.clear()
harr_c.clear()
grad_aapg.clear ()
grad_harr.clear ()
calculation()
aapg1 = []
aapg2 = []
harr1 = []
harr2 = []
for i in range (len (aapg_c)):
aapg1.append ("%.2f" % aapg_c[i])
aapg2.append ("%.2f" % grad_aapg[i])
harr1.append ("%.2f" % harr_c[i])
harr2.append ("%.2f" % grad_harr[i])
if region == "Onshore":
fig1 = go.Figure(data=[go.Table(header=dict(values=['TVDgl (m.)', 'AAPG (C)', 'Harr (C)', 'AAPG Grads (C/km)', 'Harr Grads (C/km)']),
cells=dict(values=[tvd_list, aapg1, harr1, aapg2, harr2]))])
elif region == "Offshore":
fig1 = go.Figure(data=[go.Table(header=dict(values=['TVDbml (m.)', 'AAPG (C)', 'Harr (C)', 'AAPG Grads (C/km)', 'Harr Grads (C/km)']),
cells=dict(values=[tvdss_list, aapg1, harr1, aapg2, harr2]))])
fig2 = go.Figure()
if region == "Offshore":
fig2.add_trace(go.Scatter(x=aapg_c, y=tvdss_list, name="AAPG", line_color=colouraapg))
fig2.add_trace(go.Scatter(x=harr_c, y=tvdss_list, name="Harrison et al. (1983)", line_color=colourharr))
fig2.update_yaxes(title_text="TVDbml (m.)")
elif region == "Onshore":
fig2.add_trace(go.Scatter(x=aapg_c, y=tvd_list, name="AAPG", line_color=colouraapg))
fig2.add_trace(go.Scatter(x=harr_c, y=tvd_list, name="Harrison et al. (1983)", line_color=colourharr))
fig2.update_yaxes(title_text="TVDgl (m.)")
fig2.update_yaxes(autorange="reversed")
fig2.update_layout(title="Post-drill temperature analysis of {}".format(name),
xaxis_title="Temperatures (C)", legend_title="Legend")
fig3 = go.Figure()
if region == "Offshore":
fig3.add_trace(go.Scatter(x=grad_aapg, y=tvdss_list, name="AAPG Gradients", line_color=colouraapg))
fig3.add_trace(go.Scatter(x=grad_harr, y=tvdss_list, name="Harrison et al. (1983)", line_color=colourharr))
fig3.update_yaxes(title_text="TVDbml (m.)")
elif region == "Onshore":
fig3.add_trace(go.Scatter(x=grad_aapg, y=tvd_list, name="AAPG Gradients", line_color=colouraapg))
fig3.add_trace(go.Scatter(x=grad_harr, y=tvd_list, name="Harrison et al. (1983)", line_color=colourharr))
fig3.update_yaxes(title_text="TVDgl (m.)")
fig3.update_yaxes(autorange="reversed")
fig3.update_layout(title="Post-drill geothermal gradient analysis of {}".format(name),
xaxis_title="Geothermal Gradients (C/km)", legend_title="Legend")
return fig1, fig2, fig3
toplam_bas = uni_sıra.iloc[0:index, :].Toplam.sum()
st.markdown(' ')
st.markdown('**URAP üniversite sıralamasına göre, sizin üniversitenizden daha üst sıralamadaki bir üniversiteden mezun olan kişilerden, 2019 ve 2020 senelerinde Kariyer.net sitesinde yayınlanan yazılım ve veri ile alakalı iş ilanlarına {} kişi başvurmuş.**'.format(toplam_bas))
with row3_2:
st.markdown(' ')
st.markdown(' ')
st.markdown(' ')
st.markdown('**Bu bölüm mezunlarını arayan Linkedinde bulunan {} ilana toplamda {} başvuru yapılmış.**'.format(len(filtered), int(filtered['Başvuru Sayısı'].sum())))
basvuru = filtered.groupby('Pozisyon')['Başvuru Sayısı'].sum().round().to_frame().reset_index().sort_values('Başvuru Sayısı', ascending = False)
fig = go.Figure(data=[go.Table(
header=dict(values=list(['Pozisyon', 'Başvuru Sayısı']),
fill_color= '#f63366',
font=dict(color='white'),
align='center', ),
cells=dict(values=[basvuru['Pozisyon'], basvuru['Başvuru Sayısı']],
fill_color='#f0f2f6',
align='center'))
])
fig.update_layout(
margin=dict(l=50, r=0, b=0, t=0)
)
fig.update_layout(width=600)
st.plotly_chart(fig)
st.markdown('__________________________________________________________________________________________')
st.header('Bu alanda hangi iş ilanları var?')
#%%
adjs(pride)
#%% [markdown]
# # Creating Figures
# There are many ways to create figures. Below is one example of a table. You can save the figure to a file.
#
# ```
# conda install -c plotly
# ```
#%%
import plotly.graph_objects as go
fig = go.Figure(data=[
go.Table(header=dict(values=['A Scores', 'B Scores']),
cells=dict(values=[[100, 90, 80, 90], [95, 85, 75, 95]]))
])
fig.show()
#%% [markdown]
# # Lab 2
#%%
# [2-1] ON YOUR OWN:
# Choose a text that was not previously analyzed above from Project Gutenberg.
# 1. Write code that retrieves and writes the text to a file in the current project. You may save it to any file, but I recommend to save it to the lab2 subdirectory.
from gutenberg.acquire import load_etext
from gutenberg.cleanup import strip_headers
from textblob import TextBlob
rowEvenColor = 'lightgrey'
rowOddColor = 'white'
fig3 = go.Figure(data=[
go.Table(
header=dict(values=[
'<b>Features</b>', '<b>GBoost</b>', '<b>XGBoost</b>',
'<b>LightGBM </b>'
],
line_color='darkslategray',
fill_color=headerColor,
align=['left', 'center'],
font=dict(color='white', size=12)),
cells=dict(
values=
[['Time', 'Huber Loss', 'Best Parameter'],
['31.2 min', 0.67, 'min_sample_split:0.5, max_features: sqrt '],
[
'13.36 min', 0.82,
'colsample_bytree: 1.0, XGB__learning_rate: 0.07'
], ['17.27 min', 0.87, 'learning_rate=0.1, n_estimators=1000']],
line_color='darkslategray',
# 2-D list of colors for alternating rows
fill_color=[[rowOddColor, rowEvenColor, rowOddColor, rowEvenColor]
* 3],
align=['left', 'center'],
font=dict(color='darkslategray', size=11)))
])
fig3.show()
path = "{0}{1}/{2}/{3}/{4}_TimeMemoryInfo.log".format(data_path,cmssw,gcc,workflow,step)
df = log_object.Get_TimeMem(path)
hex_number = '#'+str(hex(random.randint(0,16777215)))[2:].zfill(6)
fig.add_trace(go.Scatter(x=df["event"],y=df["rss"],mode="lines",line=dict(color=hex_number),legendgroup=cmssw,hovertext=cmssw,name=cmssw),row=2,col=1)
fig.add_trace(go.Scatter(x=df["event"],y=df["vsize"],mode="lines",line=dict(color=hex_number),legendgroup=cmssw,hovertext=cmssw,name=cmssw,showlegend=False),row=2,col=2)
fig.add_trace(go.Scatter(x=df["event"],y=df["time"],mode="lines",line=dict(color=hex_number),legendgroup=cmssw,hovertext=cmssw,name=cmssw,showlegend=False),row=2,col=3)
fig.add_trace(go.Histogram(x=df["rss"],nbinsx=20,bingroup=1,marker_color=hex_number,opacity=0.50,legendgroup=cmssw,hovertext=cmssw,name=cmssw,showlegend=False),row=3,col=1)
fig.add_trace(go.Histogram(x=df["vsize"],nbinsx=20,bingroup=2,marker_color=hex_number,opacity=0.50,legendgroup=cmssw,hovertext=cmssw,name=cmssw,showlegend=False),row=3,col=2)
fig.add_trace(go.Histogram(x=df["time"],nbinsx=20,bingroup=3,marker_color=hex_number,opacity=0.50,legendgroup=cmssw,hovertext=cmssw,name=cmssw,showlegend=False),row=3,col=3)
max_rss.append("{0}({1})".format(df['rss'].max(),df['event'][df['rss'].idxmax()]))
max_vsize.append("{0}({1})".format(df['vsize'].max(),df['event'][df['vsize'].idxmax()]))
max_time.append("{0}({1})".format(df['time'].max(),df['event'][df['time'].idxmax()]))
avrg_time.append(str(round(df['time'].sum()/len(df['time']),4)))
fig.add_trace(go.Table(header=dict(values=['VERSION', '(RSS)MaxMemory(evt)','(VSIZE)MaxMemory(evt)','AverageTime','MaxTime(evt)']),
cells=dict(height=30,values=[version,max_rss,max_vsize,avrg_time,max_time])),
row=1,col=1)
fig.update_layout(barmode='overlay')
fig.update_layout(
height=1500,
width=1500,
title={
'text':"Summary of Time and Memory test : {0}_X_{1}".format(version,step),
'x':0.5,
'y':0.98,
'xanchor':'center',
'yanchor':'top',
'font':dict(size=20)},
legend=dict(
orientation="h",
formatters = build_formatters(aa, 'int64')
print(aaa.to_html(formatters=formatters))
print(place_value(aa))
print("{:,}".format(aaa))
#aa=a.iloc[:, lambda a: a.columns.str.contains('location|total_cases|total_deaths',
# case=True)].head(10)
#
#
fig = go.Figure(data=[go.Table(
header=dict(values=list(aa.columns),
fill_color='paleturquoise',
align='left'),
cells=dict(values=[aa.location, aa.total_cases, aa.total_deaths],
fill_color='lavender',
align='left'))
])
fig.write_html("file3.html")
print(aa.to_html(float_format=lambda x: '{:,}'.format(x)))
#plotly.offline.plot(fig, filename = 'filename.html', auto_open=False)
#import plotly.express as px
#
#fig =px.scatter(x=range(10), y=range(10))
#fig.write_html("file.html")
def index():
# Check if user is loggedin
if 'loggedin' in session:
cursor = mysql.connection.cursor(MySQLdb.cursors.DictCursor)
cursor.execute('SELECT * FROM accounts WHERE id = %s',
(session['id'], ))
account = cursor.fetchone() # Fetch the first row only
#Grab sensor value from current user accounts!!!
device_id = account['dev_id']
# device_id = session['dev_id']
#Tells the number of records already present in table for specific device id
cursor.execute("SELECT COUNT(id) FROM glucose_value WHERE sensor = %s",
(device_id, ))
old_rowcount = cursor.fetchone()["COUNT(id)"]
print("Number of records present in glucose_value Table for",
device_id, "=", old_rowcount)
#Now specifing channels for each sensor alloted to user
if device_id == "product1":
thingspeak_cha = requests.get(
'https://api.thingspeak.com/channels/1077581/feeds.json')
elif device_id == "product2":
thingspeak_cha = requests.get(
'https://api.thingspeak.com/channels/1077581/feeds.json')
elif device_id == "product3":
thingspeak_cha = requests.get(
'https://api.thingspeak.com/channels/1077581/feeds.json')
elif device_id == "product4":
thingspeak_cha = requests.get(
'https://api.thingspeak.com/channels/1077581/feeds.json')
elif device_id == "product5":
thingspeak_cha = requests.get(
'https://api.thingspeak.com/channels/1077581/feeds.json')
print(thingspeak_cha)
dic_thingspeak = json.loads(thingspeak_cha.text)
#Printing Dictionary
print(dic_thingspeak)
#Showing type as dictionary
print(type(dic_thingspeak))
# Actually it's a dict with two keys "channel" and "feeds".
# The first one has another dict for value, and the second a list of dicts.
list_of_dic_feeds = dic_thingspeak["feeds"]
# Printing list of Dictionaries having channel data
print(list_of_dic_feeds)
# Showing Type as list
print(type(list_of_dic_feeds))
new_rowcountjson = len(list_of_dic_feeds)
print("Number of records present in thingspeak channel =",
new_rowcountjson)
# Slicing list of data present in channel to get only the new records,
# that are to be appended in MySQL glucose_value table
new_newlist = list_of_dic_feeds[old_rowcount:]
print("Number of new records present in thingspeak channel =",
len(new_newlist))
# Iterate over the list, for inserting new data of thingspeak channel into MySQL glucose_value Table:
for entry in new_newlist:
# Getting the value for the specific keys present in list of dic
n_id = entry["entry_id"]
n_glucose = entry["field1"]
n_date = entry["created_at"]
insert_stmt = (
"INSERT INTO glucose_value (glucose, timestamp, sensor) "
"VALUES (%s, %s, %s)")
data = (n_glucose, n_date, device_id)
cursor.execute(insert_stmt, data)
mysql.connection.commit()
# Now Retrieving data from MYSQL glucose_value Table to plot graph and Table using Plotly library
cursor.execute("SELECT * FROM glucose_value WHERE sensor = %s",
(device_id, ))
tupleofdic = cursor.fetchall()
listofdic = list(tupleofdic)
glucolist = []
datelist = []
SNolist = []
for dic in listofdic:
glucose_ = dic['glucose']
timestamp_ = dic['timestamp']
id_ = dic['id']
datelist.append(timestamp_)
glucolist.append(glucose_)
SNolist.append(id_)
print(glucolist)
print(datelist)
print(SNolist)
#For Starting S.No from 1 in the Table:
print(len(SNolist))
S_No_list = [*range(1, (len(SNolist) + 1), 1)]
#
formatteddate_list = []
for x in datelist:
formatteddate_list.append(x.strftime("%b %d, %Y"))
print(formatteddate_list)
formattedtime_list = []
for x in datelist:
formattedtime_list.append(x.strftime("%H:%M:%S"))
print(formattedtime_list)
#
# For Finding id of last element present in glucose_value table of specific sensor,
# for displaying the last updated date and glucose value
cursor.execute('SELECT MAX(id) FROM glucose_value WHERE sensor = %s',
(device_id, ))
max_id_dic = cursor.fetchone()
max_id = max_id_dic["MAX(id)"]
print(max_id)
cursor.execute('SELECT * FROM glucose_value WHERE id = %s', (max_id, ))
glcodata = cursor.fetchone() # Fetch the first row only
print(glcodata)
#Ploting graph using plotly format
fig = go.Figure(data=go.Scatter(x=datelist, y=glucolist))
fig.update_layout(xaxis_title='Date', yaxis_title='Glucose (mg/dL)')
fig.update_xaxes(
rangeslider_visible=True,
rangeselector=dict(buttons=list([
dict(count=1, label="1h", step="hour", stepmode="backward"),
dict(count=1, label="1d", step="day", stepmode="backward"),
dict(count=7, label="1w", step="day", stepmode="backward"),
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.show()
graphJSON = json.dumps(fig, cls=plotly.utils.PlotlyJSONEncoder)
scatter = graphJSON
#Ploting Table using plotly format
headerColor = '#636EFA'
rowEvenColor = 'rgb(179,205,227)'
rowOddColor = 'white'
fig1 = go.Figure(data=[
go.Table(
header=dict(values=[
'<b>S.No</b>', '<b>Date</b>', '<b>Time</b>',
'<b>Glucose (mg/dL)</b>'
],
line_color='darkslategray',
fill_color=headerColor,
align=['left', 'center'],
font=dict(color='white', size=22)),
cells=dict(
values=[
S_No_list,
formatteddate_list,
formattedtime_list,
glucolist,
],
line_color='darkslategray',
# 2-D list of colors for alternating rows
fill_color='rgb(203,213,232)',
# fill_color=[[rowOddColor, rowEvenColor, rowOddColor, rowEvenColor, rowOddColor] * 5],
align=['left', 'center'],
font=dict(color='black', size=14),
height=30))
])
# fig1.show()
graphJSON = json.dumps(fig1, cls=plotly.utils.PlotlyJSONEncoder)
table = graphJSON
#
return render_template('index.html',
account=account,
params=params,
plot=scatter,
glcodata=glcodata,
plot1=table)
# User is not loggedin redirect to login page
return redirect(url_for('newlogin'))
def plot_fetures(all_info_severe, all_info_mild, save_to_html=False):
"""
Display the features.
Parameters
----------
all_info_severe:
all_info_mild:
save_to_html: e.g. results.html
"""
# all_info_severe = pd.read_csv('all_info.csv')
all_info_severe['date'] = (
pd.to_datetime(all_info_severe['StudyDate']) -
pd.to_datetime(all_info_severe['StudyDate']).iloc[0]).map(get_days)
# all_info_mild = pd.read_csv('all_info_mild.csv')
all_info_mild['date'] = (
pd.to_datetime(all_info_mild['StudyDate']) -
pd.to_datetime(all_info_mild['StudyDate']).iloc[0]).map(get_days)
fig = make_subplots(rows=3,
cols=1,
shared_xaxes=True,
vertical_spacing=0.03,
specs=[[{
"type": "table"
}], [{
"type": "table"
}], [{
"type": "scatter"
}]])
# line plot - mild
fig.add_trace(
go.Scatter(
x=all_info_mild["date"],
y=all_info_mild["ratio"],
mode="lines",
name="Mild-ratio",
# fillcolor='Green',
# marker={mark.color:'Green'},
marker={
'color': 'green',
'opacity': 0.3,
'size': 30
}),
row=3,
col=1)
# line plot - severe
fig.add_trace(
go.Scatter(
x=all_info_severe["date"],
y=all_info_severe["ratio"],
mode="lines",
name="Severe-ratio", # mouse hover event trace
marker={
'color': 'red',
'opacity': 0.3,
'size': 30
}),
row=3,
col=1)
# table - mild
fig.add_trace(
go.Table(
header=dict(
values=[
'patient<br>ID',
'slice',
'spacing',
'shape',
'Patient<br>Sex',
'Study<br>Date',
'Inst.<br>Name', # Inst.
'Age',
'Severe',
'lung',
'lesion',
'ratio',
'lung<br>lesion',
'left<br>lung',
'right<br>lung',
'left<br>lesion',
'right<br>lesion',
'left<br>ratio',
'right<br>ratio',
'weighted<br>lesion',
'weighted<br>lung<br>lesion',
'left<br>weighted<br>lesion',
'right<br>weighted<br>lesion',
'consolidation',
'lesion<br>consolidation',
'left<br>consolidation',
'right<br>consolidation',
'z',
'left<br>z',
'right<br>z'
],
font=dict(size=10),
align="left"),
cells=dict(values=[
all_info_mild[k].tolist() for k in all_info_mild.columns[1:]
if k not in ['index', 'filename', 'Manufacturer', 'date']
],
align="left")),
row=2,
col=1)
# table - severe
fig.add_trace(
go.Table(
header=dict(
values=[
'patient<br>ID',
'slice',
'spacing',
'shape',
'Patient<br>Sex',
'Study<br>Date',
'Inst.<br>Name', # Inst.
'Age',
'Severe',
'lung',
'lesion',
'ratio',
'lung<br>lesion',
'left<br>lung',
'right<br>lung',
'left<br>lesion',
'right<br>lesion',
'left<br>ratio',
'right<br>ratio',
'weighted<br>lesion',
'weighted<br>lung<br>lesion',
'left<br>weighted<br>lesion',
'right<br>weighted<br>lesion',
'consolidation',
'lesion<br>consolidation',
'left<br>consolidation',
'right<br>consolidation',
'z',
'left<br>z',
'right<br>z'
],
font=dict(size=10),
align="left"),
cells=dict(values=[
all_info_severe[k].tolist()
for k in all_info_severe.columns[1:]
if k not in ['index', 'filename', 'Manufacturer', 'date']
],
align="left")),
row=1,
col=1)
fig.update_layout(
height=1000,
showlegend=False,
title_text=
"Severe(First table; Red) and Mild(Second table; Green) patient tables and progress curves",
)
fig.show()
if save_to_html:
fig.write_html('Feature.html')
def pitcher_stat(value1, value2):
scores, df = pitcher_yearly_base(value1, value2)
fig1 = go.Figure(
go.Bar(x=scores[-1][3:],
y=['평균실점(RA9) ', '평균자책점(ERA) ', '수비무관투구(FIP) '],
orientation='h',
marker_color='#000000',
width=0.4,
opacity=0.6))
fig1.update_layout(margin=dict(l=0, r=0, t=0, b=0),
template='plotly_white',
yaxis=dict(showticklabels=True,
ticks='',
tickfont_size=15),
height=300,
showlegend=False)
fig2 = make_subplots(rows=2,
cols=1,
shared_xaxes=True,
vertical_spacing=0.1,
specs=[[{
"type": "scatter"
}], [{
"type": "table"
}]])
fig2.add_trace(
go.Scatter(x=df['YEAR'],
y=df['RA9'],
name='평균실점(RA9)',
marker_color='#243858'))
fig2.add_trace(
go.Scatter(x=df['YEAR'],
y=df['ERA'],
name='평균자책점(ERA)',
marker_color='#EC7D7A'))
fig2.add_trace(
go.Scatter(x=df['YEAR'],
y=df['FIP'],
name='수비무관투구(FIP)',
marker_color='#F5CA6F'))
fig2.add_trace(
go.Table(
columnorder=[1, 2, 3, 4, 5],
columnwidth=[7.5, 10, 10, 10, 10],
header=dict(values=['YEAR', 'RA9', 'ERA', 'FIP'],
height=32,
fill_color='#6E757C',
line_color='#6E757C',
align='center',
font=dict(color='white')),
cells=dict(values=[df.YEAR, df.RA9, df.ERA, df.FIP],
fill_color='white',
line_color='#6E757C',
font=dict(color='black'),
align='center',
height=32),
), 2, 1)
fig2.update_layout(height=695,
margin=dict(l=0, r=0, t=0, b=0),
template='plotly_white',
yaxis=dict(anchor="free",
side="left",
position=0.015),
xaxis=dict(tickmode='linear', dtick=1),
legend=dict(orientation="h",
yanchor="bottom",
y=1.02,
xanchor="left",
x=0))
return fig1, fig2
abooks_nonfiction = abooks_nodupes[abooks_nodupes['Genre'] == 'Non Fiction']
#Top 20 fiction and top 20 non-fiction
abooks_nonfiction = abooks_nonfiction[0:20]
abooks_topfiction = abooks_fiction[0:20]
atopfic_table = go.Figure(data=[
go.Table(
header=dict(values=['Title', 'Author(s)'],
line_color='darkslategray',
fill_color='lightgray',
font_color='black',
font_size=14,
align='left'),
cells=dict(
values=[
abooks_topfiction['Name'], # 1st column
abooks_topfiction['Author']
], # 2nd column
line_color='darkslategray',
fill_color='powderblue',
font_size=14,
font_color='black',
align='left'))
])
atopnonfic_table = go.Figure(data=[
go.Table(
header=dict(values=['Title', 'Author(s)'],
line_color='darkslategray',
fill_color='lightgray',
font_size=14,
examples = y2.shape[0]
y2 = y2.reshape(1, examples)
Y2 = np.eye(digits)[y2.astype('int32')]
Y2 = Y2.T.reshape(digits, examples).T
# Classification
svmF1, svmPrec, svmRecall, svmAcc, svmTime = fc.svmClassifier(
train_data, test_data, train_labels, test_labels)
mlpF1, mlpPrec, mlpRecall, mlpAcc, mlpTime = fc.MLPclassifier(X, Y, X2, Y2)
cnnF1, cnnPrec, cnnRecall, cnnAcc, cnnTime = fc.CNNclassifier(X, Y, X2, Y2)
lstmF1, lstmPrec, lstmRecall, lstmAcc, lstmTime = fc.lstmAE(X, Y, X2, Y2)
# plot the result: f1 score, precision score, recall score, accuracy and time complexity
fig = go.Figure(data=[
go.Table(columnwidth=[800],
header=dict(values=['', 'SVM', 'MLP', 'CNN', 'LSTM'],
align='left'),
cells=dict(values=[
[
'F1 Score', 'Precision Score', 'Recall Score', 'Accuracy',
'Time Complexity'
],
[svmF1, svmPrec, svmRecall, svmAcc, svmTime],
[mlpF1, mlpPrec, mlpRecall, mlpAcc, mlpTime],
[cnnF1, cnnPrec, cnnRecall, cnnAcc, cnnTime],
[lstmF1, lstmPrec, lstmRecall, lstmAcc, lstmTime],
],
fill=dict(color=['paleturquoise', 'white']),
align='left'))
])
fig.write_image("Table.pdf")
for one,two in itertools.zip_longest(file1set,file2set, fillvalue='nothing'):
line.append(one)
if one != two:
result.append("DIFFERENT: (in file 2: " + two + ")")
else:
result.append("same")
for i in range(len(line)):
i+= 1
lineNum.append(i)
print(line)
print(result)
# generate table
fig = go.Figure(data=[go.Table(
columnorder = [1,2,3],
columnwidth = [30,200,100],
header=dict(values=['line','line content', 'result'],
line_color='white',
fill_color='lightgray',
align='left',
font_color='white'),
cells=dict(values=[lineNum, line, result],
line_color='white',
fill_color='lavenderblush',
align='left',
font_color='darkgray'))
])
fig.show()
fig.add_trace(go.Choropleth(colorscale='BuGn',
locationmode='country names',
locations=dff['Country'],
marker_line_color='gray',
marker_opacity=0.75,
marker_line_width=0.5,
showscale=False,
z=dff['Share_2016'],
hoverinfo='z+location'),
row=1,
col=1)
fig.add_trace(go.Table(
header=dict(align="center",
fill_color="rgba(98, 192, 165, 0.46)",
font_size=10,
values=df.columns[1:].tolist()),
cells=dict(
values=[df.query('date==2016')[k].tolist() for k in df.columns[1:]],
align="center"),
),
row=2,
col=1)
buttons = []
for year in [2005, 2016]:
dfp = df.query('date==@year').reset_index()
buttons.append(
dict(method='update',
label=str(year),
args=[{
"cells":
def calculate(start_date,
end_date,
ma_filter,
up_down_filter,
ma_filter_len=1,
holding_day=1):
startdatetime = pd.to_datetime(start_date)
enddatetime = pd.to_datetime(end_date)
# start_year = start_date.year
# start_month = start_date.month
# start_day = start_date.day
# end_year = end_date.year
# end_month = end_date.month
# end_day = end_date.day
moving_avg_updown = int(ma_filter) #0不篩選 1為篩選收均線以上 -1為篩選收均線以下
up_down = int(up_down_filter) # 0不篩選漲跌, 1為篩上漲, 2為篩下跌
moving_avg = int(ma_filter_len)
holddays = int(holding_day)
url = "https://api.finmindtrade.com/api/v3/data"
parameter = {
"dataset": "TaiwanStockPrice",
"stock_id": "TAIEX",
"date": "2001-01-01",
"end_date": date.today().strftime("%Y-%m-%d"),
}
resp = requests.get(url, params=parameter)
data = resp.json()
data = pd.DataFrame(data["data"])
data['date'] = pd.to_datetime(data['date'])
data = data.drop(
columns=['stock_id', 'Trading_money', 'spread', 'Trading_turnover'])
data = data[['date', 'open', 'max', 'min', 'close', 'Trading_Volume']]
data.columns = ['Date', 'Open', 'High', 'Low', 'Close', 'Volume']
data["datetime"] = data['Date'] # 日期
data['moving_avg'] = 0 # 均線的價格
data['moving_avg_updown'] = 0 # 收盤在該均線上或下
data['up_down'] = 0 # 當日漲或跌
data['end_price'] = 0 # 持有到結束時的收盤價
data['return_percent'] = 0 # 報酬率
def on_avg(row):
ans = 0
if row['Close'] > row['moving_avg']:
ans = 1
elif row['Close'] < row['moving_avg']:
ans = -1
return ans
def on_avg_ud(row):
ans = 0
if row['Close'] > row['Close_lag1']:
ans = 1
elif row['Close'] < row['Close_lag1']:
ans = 2
return ans
data['moving_avg'] = data['Close'].rolling(moving_avg).mean()
data['moving_avg_updown'] = data.apply(on_avg, axis=1)
data['Close_lag1'] = data['Close'].shift(1)
data['up_down'] = data.apply(on_avg_ud, axis=1)
data = data.drop(columns=['Close_lag1'])
data['end_price'] = data['Close'].shift(-holddays)
data['return_percent'] = 100 * (data['end_price'] -
data['Close']) / data['Close']
# for i in range(0, data.shape[0]): # 讀取資料 填入欄位資料：日期 均線平均 均線上下 持有到到期價格等
# data.loc[i, 'datetime'] = datetime.datetime.strptime(data.loc[i][0],"%Y/%m/%d")
# if i >= moving_avg-1:
# sum_temp = 0
# for j in range(moving_avg):
# sum_temp += data.loc[i-j,'Close']
# if moving_avg != 0:
# data.loc[i, 'moving_avg'] = sum_temp/moving_avg
# if data.loc[i,'Close'] > data.loc[i, 'moving_avg']:
# data.loc[i, 'moving_avg_updown'] = 1
# elif data.loc[i,'Close'] < data.loc[i, 'moving_avg']:
# data.loc[i, 'moving_avg_updown'] = -1
# if i > 0:
# if data.loc[i,'Close'] > data.loc[i-1,'Close']:
# data.loc[i, 'up_down'] = 1
# elif data.loc[i,'Close'] < data.loc[i-1,'Close']:
# data.loc[i, 'up_down'] = 2
# if i+holddays < data.shape[0]:
# data.loc[i, 'end_price'] = data.loc[i+holddays,'Close']
# data.loc[i, 'return_percent'] = 100* ((data.loc[i, 'end_price'] - data.loc[i,'Close'])/data.loc[i,'Close'])
# print(sum(data['up_down2'] != data['up_down']))
# print(sum(data['end_price2'] != data['end_price']))
# print(sum(data['return_percent2'] != data['return_percent']))
# data.to_csv('test.csv')
# temp0 = 0
# temp1 = 0
# temp2 = 0
# temp3 = data.shape[0]
data0 = []
data1 = []
data2 = []
data3 = []
# 取得設定的開始及結束日期內的資料
# for i in range(0,data.shape[0]):
# if temp0 == 0:
# if (data.loc[i,'datetime']-startdatetime).days>=0:
# temp0 = 1
# temp2 = i
# #data0 = data[i:]
# if temp0 == 1 and temp1 == 0:
# if (data.loc[i,'datetime']-enddatetime).days>0:
# temp1 = 1
# temp3 = i
# time_mask = (data['datetime'] >= startdatetime) and (data['datatime'] <= enddatetime)
data0 = data[(data['datetime'] >= startdatetime)
& (data['datetime'] <= enddatetime)]
# data0 = data[temp2:temp3]
# 取得要的濾網及漲跌資料
if up_down != 0:
data1 = data0[data0["up_down"] == up_down]
else:
data1 = data0
if moving_avg_updown != 0:
data2 = data1[data1["moving_avg_updown"] == moving_avg_updown]
else:
data2 = data1
data3 = data2[data2["end_price"] != 0]
if len(data3) >= 1:
return_count = list(data3['return_percent'].to_numpy())
import math
tmp = data3['return_percent'].describe()
tmp['skew'] = data3['return_percent'].skew()
tmp['kurtosis'] = data3['return_percent'].kurtosis()
# 以下數行為輸出敘述統計量資料
import plotly.graph_objects as go
df = pd.DataFrame()
df['Statistics'] = tmp.index
df['value'] = tmp.values
df = df.round(4)
table = go.Figure(data=[
go.Table(header=dict(values=list(df.columns),
fill_color='#3474eb',
align='left',
font=dict(color='white', size=12)),
cells=dict(values=[df['Statistics'], df.value],
fill_color='lavender',
align='left'))
])
import plotly.offline as opy
table.update_layout(width=400, height=500)
plot_div = opy.plot(table, auto_open=False, output_type='div')
endpoints = []
# 以下數行轉換長條圖到折線位置上
for i in range(
int(10 * data3['return_percent'].min()) - 1,
int(10 * data3['return_percent'].max()) + 1, 1):
endpoints.append(i / 10)
n, bins, _ = plt.hist(return_count,
bins=endpoints,
density=1,
facecolor="gray",
edgecolor="black")
plt.cla()
n = n / 10
bins2 = []
for i in range(len(bins) - 1):
bins2.append((bins[i] + bins[i + 1]) / 2)
# 以下數行為輸出結果的折線圖
plt.plot(bins2, n)
plt.xlabel("Return (percent)", fontsize=20)
plt.ylabel("Probability", fontsize=20)
plt.title("Probability Function", fontsize=20)
plt.xlim(data3['return_percent'].min() - 0.1,
data3['return_percent'].max() + 0.1) # 要顯示的範圍(報酬百分比)
plt.ylim(0)
ax = plt.gca()
ax.spines['right'].set_visible(False)
ax.spines['top'].set_visible(False)
buffer = io.BytesIO()
plt.savefig(buffer, format='png')
buffer.seek(0)
image_png = buffer.getvalue()
buffer.close()
graph = base64.b64encode(image_png)
graph = graph.decode('utf-8')
return plot_div, graph
else:
print('符合回測條件的開盤天數為0')
