def topic_fig(series, n):
labels = [f'Topic {i}' for i in range(n)]
fig = go.Figure(data=[go.Pie(labels=labels, values=percentages, hole=0.6)])
fig.update_traces(textposition='outside', textinfo='percent+label')
return fig
if len(plot_serviceprovider_active) > 0:
for i in range(len(plot_serviceprovider_active)):
fig.add_trace(
go.Scattergeo(
locationmode = 'ISO-3',
lon = [plot_serviceprovider_active['SP_lng'][i], plot_serviceprovider_active['DL_lng'][i]],
lat = [plot_serviceprovider_active['SP_lat'][i], plot_serviceprovider_active['DL_lat'][i]],
mode = 'lines',
line = dict(width = 1,color = 'green'),
showlegend=False
#opacity = float(df_flight_paths_2['cnt'][i]) / float(df_flight_paths_2['cnt'].max()),
)
)
fig.update_layout(
title_text = 'Optimierte Bezugsplanung für das Ersatzteil Test-1 <br>(Mouseover für Detailinformationen zum jeweiligen Standort)',
showlegend = True,
geo = go.layout.Geo(
scope = 'world',
projection_type = 'natural earth',
showland = True,
landcolor = 'rgb(243, 243, 243)',
countrycolor = 'rgb(204, 204, 204)',
),
)
fig.add_trace(go.Pie(values=[2, 3, 1]),
row=2, col=1)
fig.show()
def update_graph_live(n):
devices_on = 0
for key, value in ecosystem_status.items():
# print(key, value)
if value == 1:
devices_on += 1
overview_devices_on.append(devices_on)
overview_smartflow_status.append(int(ecosystem_status['smartflow_status']))
# Create the graph with subplots
fig = plotly.subplots.make_subplots(
rows=3,
cols=10,
specs=[[{
'type': 'domain',
"colspan": 3,
"rowspan": 3
}, None, None, {
"colspan": 6
}, None, None, None, None, None, None],
[
None, None, None, {
"colspan": 6,
"rowspan": 2
}, None, None, None, None, None, None
], [None, None, None, None, None, None, None, None, None,
None]],
subplot_titles=("", "Status", "Active Devices", "", "", "", "", "", "",
"", "", "", "", "", "", "", "", "", "", ""),
shared_xaxes=True)
fig['layout']['margin'] = {'l': 100, 'r': 10, 'b': 0, 't': 50}
fig['layout']['legend'] = {
'orientation': 'v',
'borderwidth': 2,
'x': -0.01,
'y': 1
}
device_bar = go.Bar(x=list(overview_times),
y=list(overview_devices_on),
name='Devices Active',
text=list(overview_devices_on),
textposition='outside',
marker=dict(color='#0000FF'))
labels = ['Anomalous', 'Normal']
normal = 0
anomalous = 0
for entry in list(overview_smartflow_status):
if entry is 0:
normal += 1
elif entry is 1:
anomalous += 1
print(list(overview_smartflow_status))
values = [anomalous, normal]
colors = ['#FF0000', '#32CD32']
system_pie = go.Pie(labels=labels,
hole=.3,
values=values,
hoverinfo='label+percent',
marker=dict(colors=colors))
fig.append_trace(
{
'x':
list(overview_times),
'y':
list(overview_smartflow_status),
'yaxis':
'y2',
'name':
'Smartflow Status',
'mode':
'markers+lines',
'fill':
'tozeroy',
'marker':
dict(size=15,
color=(set_color(
list(overview_smartflow_status)[
len(list(overview_smartflow_status)) - 1]))),
'type':
'scatter',
}, 1, 4)
fig.append_trace(system_pie, 1, 1)
fig.append_trace(device_bar, 2, 4)
fig.update_layout(title_text='[---OVERVIEW---]',
font=dict(family='Courier New, monospace',
color='#1A1A1A'),
paper_bgcolor='#C2C5CC',
plot_bgcolor='#C2C5CC',
height=300,
yaxis=dict(range=(0, 1)),
yaxis2=dict(range=(0, 10)))
return fig
def get_pie_chart(labels, sizes):
fig = go.Figure(data=[go.Pie(labels=labels, values=sizes)])
return fig.to_html(full_html=False, default_height=800, default_width=1000)
def twitter_page(n_clicks, twitterhandle):
if n_clicks > 0:
# Extract 1000 tweets from twitter user
posts = api.user_timeline(screen_name=twitterhandle,
count=10000,
lang="en",
tweet_mode="extended")
# Create dataframe
df = pd.DataFrame([tweet.full_text for tweet in posts],
columns=['Tweets'])
# Clean text
# Create function to clean tweets
def cleanTxt(text):
text = re.sub(r'@[A-Za-z0-9]+', '', text) #removes @mentions
text = re.sub(r'#', '', text) #removes '#'
text = re.sub(r'RT[\s]+', '', text) # removes RT
text = re.sub(r'https?:\/\/\S+', '', text) #removes links
return text
df['Text'] = df['Tweets'].apply(cleanTxt)
# Create function to get the subjectivity
def getSubjectivity(text):
return TextBlob(text).sentiment.subjectivity
# Create function to get the polarity
def getPolarity(text):
return TextBlob(text).sentiment.polarity
# Create two new columns
df['Subjectivity'] = df['Text'].apply(getSubjectivity)
df['Polarity'] = df['Text'].apply(getPolarity)
# Calculate the negative, neutral and positive analysis
def getAnalysis(score):
if score < 0:
return 'Negative'
elif score == 0:
return 'Neutral'
else:
return 'Positive'
df['Sentiment'] = df['Polarity'].apply(getAnalysis)
#Create Pie Chart
labels = df['Sentiment'].value_counts().index
values = df['Sentiment'].value_counts()
fig = go.Figure(data=[go.Pie(labels=labels, values=values)])
# Clean the text
allWords = ' '.join([twts for twts in df['Text']])
allWords_lower = allWords.lower()
stop = set(stopwords.words('english') + list(string.punctuation))
new_stopwords = ['...', '``', "''", '’', "'s", "n't"]
new_stopwords_list = stop.union(new_stopwords)
text_tokens = nltk.word_tokenize(allWords_lower)
text_no_stop_words_punct = [
t for t in text_tokens
if t not in new_stopwords_list and t not in string.punctuation
]
filtered_string = (" ").join(text_no_stop_words_punct)
# Convert the long string to a dictionary with frequency counts.
def word_count(str):
counts = dict()
words = str.split()
for word in words:
if word in counts:
counts[word] += 1
else:
counts[word] = 1
return counts
twitter_wordcloud = (word_count(filtered_string))
# Create Word Cloud
wc = WordCloud().generate_from_frequencies(
frequencies=twitter_wordcloud)
wc_img = wc.to_image()
with BytesIO() as buffer:
wc_img.save(buffer, 'png')
img2 = base64.b64encode(buffer.getvalue()).decode()
#Display Pie Chart and Word Cloud
twitter_results = html.Div([
html.Div(dcc.Graph(id='graph1', figure=fig),
style={
'width': '49%',
'display': 'inline-block'
}),
html.Div(children=[
html.Img(src="data:image/png;base64," + img2,
style={
'height': '50%',
'width': '50%'
})
],
style={
'width': '49%',
'display': 'block',
'textAlign': 'center'
}),
])
return twitter_results
header=dict(values=['Country', 'Year', 'Sex', 'Age', 'Population', 'Suicides/100k',
'Generation', 'GDP per capita', 'Continent'],
align='left'),
cells=dict(values=[suicides.country, suicides.year, suicides.sex, suicides.age,
suicides.population, suicides['suicides/100k'],
suicides.generation, suicides.gdp_per_capita, suicides.continent],
align='left'))
])),
className='ten columns')
]),
html.Div(className='row',
children=[
html.Div(
dcc.Graph(
id='pie-chart-continent',
figure = go.Figure(data=[go.Pie(labels=grouped_by_continent['continent'], values=grouped_by_continent['suicides/100k'],
textposition='inside')])
), className='six columns'
),
html.Div(
dcc.Graph(
id='gender-graph',
figure=px.bar(grouped_by_gender, x='year', y='suicides/100k', color='sex')
), className='six columns'
)
]),
html.Div(
className='row',
children=[
html.Div(
dcc.Graph(
id='age-graph',
name='Low Satisfaction'))
fig_job_satisfaction.update_layout(title="Job Satisfaction (%)")
# Unemployment
fig_unemployment = px.line(unemployment_data,
x="country",
y="unemp_rate",
title='Rate of Unemployment',
labels={"unemp_rate": "Unemployment rate"})
############################################ Legal ############################################
# Crime rate
fig_crime_rate = go.Figure(data=[
go.Pie(labels=crime_data['country'],
values=crime_data['prct_rpt_crime'],
hole=.3,
title="Crime Report Rate")
])
# police_trust_rating,legal_trust_rating
fig_legal_trust_subplot = go.Figure()
fig_legal_trust_subplot.add_trace(
go.Scatter(x=euro_stats_data['country'],
y=euro_stats_data['police_trust_rating'],
mode='lines',
line=dict(color='darkslateblue'),
name='Police Trust Rating'))
fig_legal_trust_subplot.add_trace(
go.Scatter(x=euro_stats_data['country'],
y=euro_stats_data['legal_trust_rating'],
def country_gender(self,df, country):
x = ["male", "female"]
onlycountry = df.loc[df["country"] == country]
year_group = onlycountry.groupby("year")["suicides_no"].sum()
plot_x = year_group.index
plot_y = year_group
age_group= onlycountry.groupby("age")["suicides_no"].sum()
pie_lables = age_group.index
pie_values = age_group
y = []
for i in x:
gender = onlycountry.loc[onlycountry["sex"] == i]
y.append(gender["suicides_no"].sum())
trace = [go.Scatter(x=plot_x, y=plot_y, mode='lines', visible=True), go.Bar(x=x, y=y, visible=False),go.Pie(labels=pie_lables,values=pie_values,visible=False)]
layout = go.Layout(title="Detail sucide count of " + country)
fig = go.Figure(data=trace, layout=layout)
fig.update_layout(
updatemenus=[
dict(type="buttons",
direction="left",
buttons=[
dict(
label="All Years",
method="update",
args=[{"type": ["scatter", "bar","pie"], "mode": ["lines", "", ""],
"visible": [True, False,False]}],
), dict(
label="Gender",
method="update",
args=[{"type": ["scatter", "bar","pie"], "mode": ["lines", "", ""],
"visible": [False, True,False]}],
),
dict(
label="Age",
method="update",
args=[{"type": ["scatter", "bar","pie"], "mode": ["lines", "", ""],
"visible": [False, False, True]}],
)
],
pad={"r": 10, "t": 0}, showactive=True, x=0.11, xanchor="left", y=1.1, yanchor="top"
),
]
)
return fig
def qsphere(state,
state_labels=True,
state_labels_kind='bits',
as_widget=False):
"""Plots a statevector of qubits using the qsphere
representation.
Parameters:
state (ndarray): Statevector as 1D NumPy array.
state_labels (bool): Show state labels.
state_labels_kind (str): 'bits' (default) or 'ints'.
as_widget (bool): Return a widget instance.
Returns:
PlotlyFigure or PlotlyWidget: Figure instance.
Raises:
KaleidoscopeError: Invalid statevector input.
Example:
.. jupyter-execute::
from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
import kaleidoscope.qiskit
from kaleidoscope.interactive import qsphere
qc = QuantumCircuit(3)
qc.h(range(3))
qc.ch(0,1)
qc.s(2)
qc.cz(2,1)
state = qc.statevector()
qsphere(state)
"""
if state.__class__.__name__ in ['Statevector'] \
and 'qiskit' in state.__class__.__module__:
state = state.data
if state.__class__.__name__ in ['DensityMatrix'] \
and 'qiskit' in state.__class__.__module__:
if not abs(1 - state.data.dot(state.data).trace().real) < 1e-6:
raise KaleidoscopeError(
'Input density matrix is not a pure state.')
# pylint: disable=unexpected-keyword-arg
_, evecs = la.eig(state.data)
state = evecs[0].ravel()
if len(state.shape) == 2:
if not abs(1 - state.dot(state).trace().real) < 1e-6:
raise KaleidoscopeError(
'Input density matrix is not a pure state.')
# pylint: disable=unexpected-keyword-arg
_, evecs = la.eig(state.data)
state = evecs[0].ravel()
if len(state.shape) != 1:
raise KaleidoscopeError('Input state is not 1D array.')
if np.log2(state.shape[0]) % 1:
raise KaleidoscopeError('Input is not a valid statevector of qubits.')
eps = 1e-8
norm = mpl.colors.Normalize(vmin=0, vmax=2 * np.pi)
cmap = cc.cm.CET_C1s
num_qubits = int(np.log2(state.shape[0]))
xvals = []
yvals = []
zvals = []
colors = []
bases = []
probs = []
marker_sizes = []
for idx in range(2**num_qubits):
prob = (state[idx] * state[idx].conj()).real
if prob > eps:
elem = bin(idx)[2:].zfill(num_qubits)
weight = elem.count("1")
zvalue = -2 * weight / num_qubits + 1
number_of_divisions = spsp.comb(num_qubits, weight)
weight_order = _bit_string_index(elem)
angle = (float(weight) / num_qubits) * (np.pi * 2) + \
(weight_order * 2 * (np.pi / number_of_divisions))
if (weight > num_qubits / 2) or (
((weight == num_qubits / 2) and
(weight_order >= number_of_divisions / 2))):
angle = np.pi - angle - (2 * np.pi / number_of_divisions)
xvalue = np.sqrt(1 - zvalue**2) * np.cos(angle)
yvalue = np.sqrt(1 - zvalue**2) * np.sin(angle)
bases.append(elem)
probs.append(prob)
xvals.append(xvalue)
yvals.append(yvalue)
zvals.append(zvalue)
phase = np.arctan2(state[idx].imag, state[idx].real)
phase = phase if phase >= 0 else phase + 2 * np.pi
colors.append(mpl.colors.rgb2hex(cmap(norm(phase))))
marker_sizes.append(np.sqrt(prob) * 40)
if state_labels_kind == 'ints':
bases = [int(kk, 2) for kk in bases]
# Output figure instance
fig = make_subplots(rows=5,
cols=5,
specs=[[{
"type": "scene",
"rowspan": 5,
"colspan": 5
}, None, None, None, None],
[None, None, None, None, None],
[None, None, None, None, None],
[None, None, None, None, None],
[
None, None, None, None, {
"rowspan": 1,
"colspan": 1,
"type": "domain"
}
]])
figsize = (350, 350)
# List for vector annotations, if any
fig_annotations = []
fig.add_trace(BSPHERE(), row=1, col=1)
# latitudes
for kk in _qsphere_latitudes(zvals):
fig.add_trace(kk, row=1, col=1)
fig.add_trace(go.Scatter3d(
x=[0],
y=[0],
z=[0],
mode='markers',
opacity=0.6,
marker=dict(size=4, color='#555555'),
),
row=1,
col=1)
for kk, _ in enumerate(xvals):
fig.add_trace(go.Scatter3d(x=[0, xvals[kk]],
y=[0, yvals[kk]],
z=[0, zvals[kk]],
mode="lines",
hoverinfo=None,
opacity=0.5,
line=dict(color=colors[kk], width=3)),
row=1,
col=1)
if state_labels:
xanc = 'center'
if xvals[kk] != 0:
if xvals[kk] < 0:
xanc = 'right'
else:
pass
yanc = 'middle'
if zvals[kk] != 0:
if zvals[kk] < 0:
yanc = 'top'
else:
yanc = 'bottom'
fig_annotations.append(
dict(
showarrow=False,
x=xvals[kk] * 1.1,
y=yvals[kk] * 1.1,
z=zvals[kk] * 1.1,
text="<b>|{}\u3009</b>".format(bases[kk]),
align='left',
opacity=0.7,
xanchor=xanc,
yanchor=yanc,
xshift=10,
bgcolor="#ffffff",
font=dict(
size=10,
color="#000000",
),
))
fig.add_trace(go.Scatter3d(
x=xvals,
y=yvals,
z=zvals,
mode='markers',
opacity=1,
marker=dict(size=marker_sizes, color=colors),
),
row=1,
col=1)
slices = 128
labels = [''] * slices
values = [1] * slices
phase_colors = [
mpl.colors.rgb2hex(cmap(norm(2 * np.pi * kk / slices)))
for kk in range(slices)
]
fig.add_trace(go.Pie(labels=labels,
values=values,
hole=.6,
showlegend=False,
textinfo='none',
hoverinfo='none',
textposition="outside",
rotation=90,
textfont_size=12,
marker=dict(colors=phase_colors)),
row=5,
col=5)
pie_x = fig.data[-1]['domain']['x']
pie_y = fig.data[-1]['domain']['y']
fig['layout'].update(annotations=[
dict(
xref='paper',
yref='paper',
x=(pie_x[1] - pie_x[0]) / 2 + pie_x[0],
y=(pie_y[1] - pie_y[0]) / 2 + pie_y[0],
text='Phase',
xanchor="center",
yanchor="middle",
showarrow=False,
font=dict(size=9),
),
dict(
xref='paper',
yref='paper',
x=pie_x[0] - 0.03,
y=(pie_y[1] - pie_y[0]) / 2 + pie_y[0],
text='\U0001D70B',
xanchor="left",
yanchor="middle",
showarrow=False,
font=dict(size=14),
),
dict(
xref='paper',
yref='paper',
x=pie_x[1] + 0.03,
y=(pie_y[1] - pie_y[0]) / 2 + pie_y[0],
text='0',
xanchor="right",
yanchor="middle",
showarrow=False,
font=dict(size=12),
),
dict(
xref='paper',
yref='paper',
x=(pie_x[1] - pie_x[0]) / 2 + pie_x[0],
y=pie_y[1] + 0.05,
text='\U0001D70B/2',
xanchor="center",
yanchor="top",
showarrow=False,
font=dict(size=12),
),
dict(
xref='paper',
yref='paper',
x=(pie_x[1] - pie_x[0]) / 2 + pie_x[0],
y=pie_y[0] - 0.05,
text='3\U0001D70B/2',
xanchor="center",
yanchor="bottom",
showarrow=False,
font=dict(size=12),
)
])
fig.update_layout(width=figsize[0],
height=figsize[1],
autosize=False,
hoverdistance=50,
showlegend=False,
scene_aspectmode='cube',
margin=dict(r=15, b=15, l=15, t=15),
scene=dict(annotations=fig_annotations,
xaxis=dict(showbackground=False,
range=[-1.2, 1.2],
showspikes=False,
visible=False),
yaxis=dict(showbackground=False,
range=[-1.2, 1.2],
showspikes=False,
visible=False),
zaxis=dict(showbackground=False,
range=[-1.2, 1.2],
showspikes=False,
visible=False)),
scene_camera=dict(eye=dict(x=0, y=-1.4, z=0.3)))
if as_widget:
return PlotlyWidget(fig)
return PlotlyFigure(fig, modebar=True)
def get_donut_graphs(df, label):
non_main = 1 - df.values[0]
labels =["main", label]
values =[non_main, df]
fig = go.Figure(data=[go.Pie(labels=labels, values=values, hole= 0.499)])
return fig
import plotly.graph_objects as go
from plotly.offline import plot
fig = go.Figure(
data=[go.Pie(labels=['bob', 'boba', 'boban'], values=[1000, 1000, 1000])])
plot(fig)
def generateReport(self):
self.determineSelection()
self.determineDateRange()
self.determineStyleSettings()
self.determineLocationsToTrack()
conn = sqlite3.connect('vmc_tap.db')
conn_results = []
title = self.title
substr = ''
for i, location in enumerate(self.location_list):
if i != (len(self.location_list) - 1):
substr += location + '\' or location = \''
else:
substr += location
conn_string_sql = "select " + self.group_by + ", count(" + self.selection + ") from visits where (location = \'" + substr + "\') and check_in_date >= \'" + self.from_time.strftime(
'%Y-%m-%d') + "\' and check_in_date <= \'" + self.to_time.strftime(
'%Y-%m-%d') + "\' group by " + self.group_by + ";"
print('location_list: ', self.location_list)
# conn_string_sql = "select location, count(" + self.selection + ") from visits group by location;"
print('conn_string_sql', conn_string_sql)
# print('conn.execute: ', conn.execute(conn_string_sql))
for d in conn.execute(conn_string_sql):
conn_results.append(d)
conn.close()
# Rotates 2D array to work w/ plotly
conn_results_rotated = list(zip(*conn_results[::-1]))
print('Conn results_rotated:', conn_results_rotated)
app = DjangoDash('Graph') # replaces dash.Dash
# print('conn_results_rotated: ', conn_results_rotated)
if conn_results_rotated == []:
x_axis = [1, 2, 3, 4, 5, 6, 7, 8]
y_axis = [1, 2, 3, 4, 5, 6, 7, 8]
# raise emptyList("List is empty")
else:
x_axis = conn_results_rotated[0]
y_axis = conn_results_rotated[1]
# for tuple in conn_results:
# x_axis.append(tuple[0])
# y_axis.append(tuple[1])
print('x_axis: ', x_axis)
print(y_axis)
layout = Layout(title=title)
fig = go.Figure(data=[
go.Pie(labels=x_axis, values=y_axis, textinfo=self.textinfo)
],
layout=layout)
# graph = [Bar(x=x_axis,y=y_axis)]
# layout = Layout(title='Length of Visits',xaxis=dict(title='Length (min)'),yaxis=dict(title='# of Visits'))
# fig = Figure(data=graph,layout=layout)
# plot_div = plot(fig,output_type='div',show_link=False,link_text="")
# Dash instance for includng a table
if self.include_table == 'Yes':
header = ['Row Labels', 'Count of Location']
x_list = list(x_axis)
y_list = list(y_axis)
values = [x_list, y_list]
print('values: ', values)
total = 0
for count in y_axis:
total += count
x_list.append('<b>Grand Total</b>')
y_list.append(total)
table = go.Figure(data=[
go.Table(header=dict(values=header), cells=dict(values=values))
])
app.layout = html.Div(children=[
dcc.Graph(id='table', figure=table),
dcc.Graph(id='figure',
figure=fig,
style={
'height': '80vh',
'width': '80vw'
}),
],
style={
'height': '40vh',
'width': '70vw'
})
else:
app.layout = html.Div(children=[
dcc.Graph(id='figure', figure=fig, style={'height': '90vh'}),
],
style={
'height': '70vh',
'width': '70vw'
})
return app, title
def output_html(
all_cve_data: Dict[ProductInfo, CVEData],
scanned_dir: str,
filename: str,
theme_dir: str,
total_files: int,
products_with_cve: int,
products_without_cve: int,
merge_report: Union[None, MergeReports],
logger: LOGGER,
outfile,
):
"""Returns a HTML report for CVE's"""
# Step 1: Load all the templates
# Root folder where html_reports is present
root = os.path.dirname(os.path.abspath(__file__))
# Template Directory contains all the html files
templates_dir = os.path.join(root, "html_reports")
templates_env = Environment(
loader=FileSystemLoader(templates_dir),
autoescape=select_autoescape(enabled_extensions=("html"),
disabled_extensions=("css,js")),
)
temp_base = "templates/base.html"
temp_dash = "templates/dashboard.html"
temp_product = "templates/row_product.html"
temp_cve = "templates/row_cve.html"
temp_intermediate = "templates/intermediate.html"
base = templates_env.get_template(temp_base)
dashboard = templates_env.get_template(temp_dash)
cve_row = templates_env.get_template(temp_cve)
product_row = templates_env.get_template(temp_product)
# Load merge template if the report is generated from intermediate reports
if merge_report:
merged = templates_env.get_template(temp_intermediate)
(
products_trace,
total_files_trace,
intermediate_timeline,
severity_trace,
) = load_timeline_from_merged(merge_report)
# Intermediate Graphs Rendering
intermediate = merged.render(
products_trace=products_trace.to_html(full_html=False,
include_plotlyjs=False),
total_files_trace=total_files_trace.to_html(
full_html=False, include_plotlyjs=False),
intermediate_timeline=intermediate_timeline.to_html(
full_html=False, include_plotlyjs=False),
severity_trace=severity_trace.to_html(full_html=False,
include_plotlyjs=False),
)
else:
intermediate = None
# Step 2: Prepare Charts
# Start generating graph with the data
# dash graph1: Products Vulnerability Graph
product_pie = go.Figure(data=[
go.Pie(
labels=["Vulnerable", "No Known Vulnerability"],
values=[products_with_cve, products_without_cve],
hole=0.4,
)
])
# Chart configuration for product_pie
product_pie.update_layout(
autosize=True,
legend_orientation="h",
)
product_pie.update_traces(
hoverinfo="label+percent",
textinfo="value",
textfont_size=14,
marker=dict(
colors=["#d80032", "#1a936f"],
line=dict(color="white", width=2),
),
)
# dash graph2: Product CVE's Graph
cve_bar = go.Figure()
for product_info, cve_data in all_cve_data.items():
# Check if product contains CVEs
if cve_data["cves"]:
if product_info.vendor != "UNKNOWN":
cve_bar.add_trace(
go.Bar(
x=[
f"{product_info.vendor}-{product_info.product}({product_info.version})"
],
y=[
0 if cve_data["cves"][0][1] == "UNKNOWN" else len(
cve_data["cves"])
],
name=f"{product_info.product}-{product_info.version}",
))
else:
cve_bar.add_trace(
go.Bar(
x=[f"{product_info.product}({product_info.version})"],
y=[
0 if cve_data["cves"][0][1] == "UNKNOWN" else len(
cve_data["cves"])
],
name=f"{product_info.product}-{product_info.version}",
))
# Chart configuration for cve_bar
cve_bar.update_layout(yaxis_title="Number of CVE's", )
all_paths = defaultdict(list)
star_warn = ""
products_found = []
# List of Products
for product_info, cve_data in all_cve_data.items():
# Check if product contains CVEs
if cve_data["cves"]:
# group product wise cves on the basis of remarks
cve_by_remark = group_cve_by_remark(cve_data["cves"])
# hid is unique for each product
if product_info.vendor != "UNKNOWN":
hid = f"{product_info.vendor}{product_info.product}{''.join(product_info.version.split('.'))}"
else:
hid = (
f"{product_info.product}{''.join(product_info.version.split('.'))}"
)
new_cves = render_cves(
hid,
cve_row,
"NEW",
cve_by_remark[Remarks.NewFound],
)
mitigated_cves = render_cves(
hid,
cve_row,
"MITIGATED",
cve_by_remark[Remarks.Mitigated],
)
confirmed_cves = render_cves(
hid,
cve_row,
"CONFIRMED",
cve_by_remark[Remarks.Confirmed],
)
unexplored_cves = render_cves(
hid,
cve_row,
"UNEXPLORED",
cve_by_remark[Remarks.Unexplored],
)
ignored_cves = render_cves(
hid,
cve_row,
"IGNORED",
cve_by_remark[Remarks.Ignored],
)
analysis_data = Counter(cve.severity for cve in cve_data["cves"])
# initialize a figure object for Analysis Chart
analysis_pie = go.Figure(data=[
go.Pie(
labels=list(analysis_data.keys()),
values=list(analysis_data.values()),
hole=0.4,
)
])
colors_avail = {
"CRITICAL": "#f25f5c",
"HIGH": "#ee6c4d",
"MEDIUM": "#f4d35e",
"LOW": "#90a955",
"UNKNOWN": "#808080",
}
colors = [colors_avail[label] for label in analysis_data.keys()]
analysis_pie.update_traces(
hoverinfo="label+percent",
textinfo="value",
textfont_size=14,
marker=dict(
colors=colors,
line=dict(color="white", width=2),
),
)
analysis_pie.update_layout(
autosize=True,
height=300,
legend_orientation="h",
margin=dict(l=0, r=20, t=0, b=0),
# paper_bgcolor="LightSteelBlue",
)
products_found.append(
product_row.render(
vendor=product_info.vendor,
name=product_info.product,
version=product_info.version,
cve_count=0 if cve_data["cves"][0][1] == "UNKNOWN" else
len(cve_data["cves"]),
severity_analysis=analysis_pie.to_html(
full_html=False, include_plotlyjs=False),
fix_id=hid,
paths=cve_data["paths"],
len_paths=len(cve_data["paths"]),
new_cves=new_cves,
mitigated_cves=mitigated_cves,
confirmed_cves=confirmed_cves,
unexplored_cves=unexplored_cves,
ignored_cves=ignored_cves,
))
if "*" in product_info.vendor:
star_warn = "* vendors guessed by the tool"
# update all_paths
for path in cve_data["paths"]:
all_paths[path].append(hid)
# Dashboard Rendering
dashboard = dashboard.render(
graph_cves=cve_bar.to_html(full_html=False, include_plotlyjs=False),
graph_products=product_pie.to_html(full_html=False,
include_plotlyjs=False),
directory=scanned_dir,
total_files=total_files,
products_with_cve=products_with_cve,
products_without_cve=products_without_cve,
)
# try to load the bigger files just before the generation of report
# css template names
css_main = "css/main.css"
css_bootstrap = "css/bootstrap.css"
style_main = templates_env.get_template(css_main)
style_bootstrap = templates_env.get_template(css_bootstrap)
# js template names
js_main = "js/main.js"
js_bootstrap = "js/bootstrap.js"
js_plotly = "js/plotly.js"
js_jquery = "js/jquery.js"
script_main = templates_env.get_template(js_main)
script_bootstrap = templates_env.get_template(js_bootstrap)
script_plotly = templates_env.get_template(js_plotly)
script_jquery = templates_env.get_template(js_jquery)
# Render the base html to generate report
outfile.write(
base.render(
date=datetime.now().strftime("%d %b %Y"),
dashboard=dashboard,
intermediate=intermediate,
scanned_dir=scanned_dir,
all_paths=all_paths,
print_mode=html_print_mode(
all_cve_data,
scanned_dir,
products_with_cve,
products_without_cve,
total_files,
star_warn,
merge_report,
version=VERSION,
full_html=False,
),
products_found="".join(products_found),
version=VERSION,
star_warn=star_warn,
style_main=style_main.render(),
style_bootstrap=style_bootstrap.render(),
script_main=script_main.render(),
script_jquery=script_jquery.render(),
script_bootstrap=script_bootstrap.render(),
script_plotly=script_plotly.render(),
))
def createFigures():
## make layout of plotly
fig = make_subplots(
rows=3, cols=3,
specs=[[{"type": "domain"},{"type": "xy", "colspan": 2}, None],
[{"type": "xy"}, {"type": "domain"}, {"type": "xy"}],
[{"type": "table", "rowspan": 1, "colspan" : 3}, None, None]], print_grid=True,
subplot_titles=("2019 Homeruns by Team", "Winker vs Suarez", "Reds Hitters By wRC+", "2019 Stolen Bases by Team",
"HR vs RBI Correlation", "Reds Hitters Roster Info")
)
## league homer query and visualization
database.execute("SELECT Team, HR FROM League")
result = database.fetchall()
labels = []
values = []
for line in result:
labels.append(line[0])
values.append(line[1])
fig.add_trace(
go.Pie(labels=labels, values=values, showlegend=False, title_font_size=25, hoverinfo='label+percent+value', textinfo='label', textfont_size=10,
marker=dict(line=dict(color='#000000', width=2))),
row=1, col=1
)
## end league homer query and visualization
## Winker vs Suarez query + visualization
database.execute("""select o.LastName, FLOOR(datediff(curdate(), r.DOB)/365) as 'Age', o.R, o.HR, o.RBI
from Outfielders o, Reds r
where o.LastName = 'Winker' and r.LastName = 'Winker'
UNION
Select t.LastName, FLOOR(datediff(curdate(), r.DOB)/365) as 'Age', t.R, t.HR, t.RBI
from ThirdBasemen t, Reds r
where t.LastName = 'Suarez' and r.LastName = 'Suarez'""")
result = database.fetchall()
names = []
age = []
runs = []
hr = []
rbi = []
count = 0
for line in result:
names.append(line[0])
age.append(int(line[1]))
runs.append(int(line[2]))
hr.append(int(line[3]))
rbi.append(int(line[4]))
while (count < 2):
fig.add_trace(
go.Bar(name='', xaxis='x1', hoverinfo="text+y", x=["Age", "Runs", "HR", "RBI"], y=[age[count], runs[count], hr[count], rbi[count]], text=names[count]),
row=1, col=2
)
count +=1
## end Winker vs Suarez query + visualization
## hitters v wRC query + visualization
database.execute("""select o.LastName, o.wRC
from Outfielders o
UNION
Select t.LastName, t.wRC
from ThirdBasemen t
UNION
select f.LastName, f.wRC
from FirstBasemen f
UNION
select c.LastName, c.wRC
from Catchers c
UNION
select s.LastName, s.wRC
from SecondBasemen s
UNION
select ss.LastName, ss.wRC
from Shortstops ss;""")
result = database.fetchall()
names=[]
wrc = []
count = 0
for line in result:
names.append(line[0])
wrc.append(line[1])
while (count < 16):
fig.add_trace(
go.Bar(name='', x=[wrc[count]], xaxis='x2',
y=[names[count]],
orientation='h'),
row=2, col=1
)
count += 1
## end hitters v wRC query + visualization
## SB by team query + visualization
database.execute("Select Team, SB FROM League;")
result= database.fetchall()
labels = []
values = []
for line in result:
labels.append(line[0])
values.append(line[1])
fig.add_trace(
go.Pie(name='',labels=labels, values=values, showlegend=False, title_font_size=25, hole=.3, textinfo='label', textfont_size=8),
row=2, col=2
)
## end SB by team query + visualization
## HR v RBI Correlation query + visualization
database.execute("""select o.LastName, o.HR, o.RBI
from Outfielders o
UNION
Select t.LastName, t.HR, t.RBI
from ThirdBasemen t
UNION
select f.LastName, f.HR, f.RBI
from FirstBasemen f
UNION
select c.LastName, c.HR, c.RBI
from Catchers c
UNION
select s.LastName, s.HR, s.RBI
from SecondBasemen s
UNION
select ss.LastName, ss.HR, ss.RBI
from Shortstops ss;""")
result= database.fetchall()
names=[]
hr = []
rbi= []
for line in result:
names.append(line[0])
hr.append(int(line[1]))
rbi.append(int(line[2]))
fig.add_trace(
go.Scatter(name="", xaxis='x3',
x=hr, y=rbi,
text=names,
textfont_size=10,
mode='markers',
marker_symbol="diamond-cross-open",
marker_size=10,
),
row=2, col=3
)
## end HR v RBI Correlation query + visualization
## roster info query + table ##
database.execute("select FirstName, LastName, date_format(DOB, '%c/%e/%Y'), Height, Weight, Country, Position from Reds;")
result = database.fetchall()
name = []
dob = []
height = []
weight = []
country = []
position = []
for line in result:
name.append(line[0]+ ' ' + line[1])
dob.append((line[2]))
height.append(line[3])
weight.append(line[4])
country.append(line[5])
position.append(line[6])
## creates table to display roster info ##
fig.add_trace(
go.Table(header=dict(values=['Name', 'Date of Birth', 'Height', 'Weight', 'Country', 'Position']),
cells=dict(values=[name, dob, height, weight, country, position]), name="Reds 2019 Hitter Info")
,
row=3, col=1
)
fig.update_layout(autosize=True,height=1650, width=1550, showlegend=False,
title={
'text': "2019 Reds Hitters Visualization",
'y': 0.99,
'x': 0.5,
'xanchor': 'center',
'yanchor': 'top',
'font_size': 50
})
## end roster info ##
fig.update_xaxes(title_text="wRC+", row=2, col=1)
fig.update_xaxes(title_text="Home Runs", row=2, col=3)
fig.update_yaxes(title_text="Runs Batted In", row=2, col=3)
#display figures
fig.show()
def vague_seuil_px():
nb_individu = 1000 # recommandé : 1000
variance_population = 5
rayon_contamination = 2
infectiosite = 0.8 # proba d'être infecté
p = 0.35 # proba d'être immunisé
d = 0.2 # proba de décès
# NOTE : si les courbes restent constantes, augmentez le rayon de contamination
# si le virus est trés mortel il n'y aura pas beaucoup de propagation
# Bleu : '#636EFA'
# Rouge : '#EF553B'
# Vert : '#00CC96'
# Violet : '#AB63FA'
# création des figures
fig = go.Figure()
fig = make_subplots(rows=2, cols=2,column_widths=[0.8, 0.2],row_heights=[0.5,0.5],subplot_titles=["population","",""],specs=[[{'type': 'xy'},{'type': 'domain'}],[{'type': 'xy', 'colspan' : 2},None]],horizontal_spacing = 0.05,vertical_spacing=0.05)
# création des courbes finales
courbe_sains = []
courbe_infectes = []
courbe_immunises = []
courbe_deces = []
# dataset
x, y = make_blobs(n_samples=nb_individu, centers=2, cluster_std=variance_population) # création du dataset
taille_pop = len(x)
numero_infecte_1 = rd.randint(0, taille_pop-1) # on choisit le premier individu infecté au hasard
coord_1er_infecte = [x[:, 0][numero_infecte_1], x[:, 1][numero_infecte_1]] # coordonnées du 1er infecté
courbe_sains.append(taille_pop - 1)
courbe_infectes.append(1)
courbe_immunises.append(0)
courbe_deces.append(0)
# 1er vague
coord_infectes = [] # cette liste sera implémentée des nouveaux cas
coord_sains = [] # liste des cas sains
for k in range(taille_pop):
if [x[:, 0][k], x[:, 1][k]] == coord_1er_infecte:
coord_infectes.append(coord_1er_infecte)
elif distance(coord_1er_infecte, [x[:, 0][k], x[:, 1][k]]) < rayon_contamination and chance_infecte(
infectiosite):
coord_infectes.append([x[:, 0][k], x[:, 1][k]])
else:
coord_sains.append([x[:, 0][k], x[:, 1][k]])
# actualisation des courbes finales
courbe_sains.append(len(coord_sains))
courbe_infectes.append(len(coord_infectes))
courbe_immunises.append(0)
courbe_deces.append(0)
# vagues 2 à la fin
coord_immunises = [] # on initialise
coord_deces = []
i = 1
while len(courbe_infectes)!=0 and courbe_sains[i-1] > courbe_sains[i] : # conditions d'état stationnaire
non_sains = []
coord_infectes1, coord_immunises = immuniser(coord_infectes, coord_immunises, p) # on sépare immunisés et infectés
coord_infectes, coord_deces = deces(coord_infectes1, coord_deces, coord_immunises, d) # on sépare les décès des infectés qu'ils restent
for k in range(len(coord_infectes)):
for j in range(len(coord_sains)):
if distance(np.array(coord_infectes)[k, :],
np.array(coord_sains)[j, :]) < rayon_contamination and np.array(coord_sains)[j,:] not in np.array(coord_infectes) and chance_infecte(infectiosite):
coord_infectes.append(list(np.array(coord_sains)[j, :]))
non_sains.append(list(np.array(coord_sains)[j, :]))
coord_sains = remove_(coord_sains, non_sains)
# pour les courbes finales
courbe_sains.append(len(coord_sains))
courbe_infectes.append(len(coord_infectes))
courbe_immunises.append(len(coord_immunises))
courbe_deces.append(len(coord_deces))
i += 1 # vague suivante
# on trace les individus de la dernière vague si il y en a
if coord_sains != []:
fig.add_trace(go.Scatter(x=np.array(coord_sains)[:, 0], y=np.array(coord_sains)[:, 1],name="sain", mode="markers", marker=dict(color='#636EFA'), showlegend=False),1,1)
if coord_infectes != []:
fig.add_trace(go.Scatter(x=np.array(coord_infectes)[:, 0], y=np.array(coord_infectes)[:, 1],name="infecté", mode="markers",marker=dict(color='#EF553B'), showlegend=False),1,1)
if coord_immunises != []:
fig.add_trace(go.Scatter(x=np.array(coord_immunises)[:, 0], y=np.array(coord_immunises)[:, 1],name='immunisé', mode="markers",marker=dict(color='#00CC96'), showlegend=False),1,1)
if coord_deces != []:
fig.add_trace(go.Scatter(x=np.array(coord_deces)[:, 0], y=np.array(coord_deces)[:, 1],name="décédé", mode="markers", marker=dict(color='#AB63FA'), showlegend=False),1,1)
fig.update_traces(hoverinfo="name") # affichage du curseur de la souris
fig.update_xaxes(showgrid=False, visible=False, row=1, col=1) # on supprime les axes
fig.update_yaxes(showgrid=False, visible=False, row=1, col=1)
# Pie finale
labels = ["sains","infectés","immunisés","décédés"]
fig.add_trace(go.Pie(values=[len(coord_sains),len(coord_infectes) ,len(coord_immunises), len(coord_deces)], labels=labels, sort=False),1,2)
# on trace les courbes finales
x_courbe = list(np.arange(0, len(courbe_sains))) # abscisses, correspond aux vagues
fig.add_trace(go.Scatter(x=x_courbe, y=courbe_sains, marker=dict(color='#636EFA'), showlegend=False, name="sains", yaxis="y",),2,1)
fig.add_trace(go.Scatter(x=x_courbe, y=courbe_infectes, marker=dict(color='#EF553B'), showlegend=False, name="infectés", yaxis="y2",),2,1)
fig.add_trace(go.Scatter(x=x_courbe, y=courbe_immunises, marker=dict(color='#00CC96'), showlegend=False, name="immunisés", yaxis="y3",),2,1)
fig.add_trace(go.Scatter(x=x_courbe, y=courbe_deces, marker=dict(color='#AB63FA'), showlegend=False, name="décédés", yaxis="y4",),2,1)
fig.update_xaxes(title_text="vague", row=2, col=1) # nom abscisses
fig.update_yaxes(title_text="nombre d'individus", row=2, col=1) # nom ordonnées
fig.add_annotation(text="Maximum d'infectés", x=courbe_infectes.index(max(courbe_infectes)), # ajouter un texte avec une flèche au pic d'infectés
y=max(courbe_infectes)+0.05*taille_pop, arrowhead=1, showarrow=True,row=2,col=1)
fig.update_traces(
hoverinfo="name+x+y", # affichage du curseur de la souris sur le point
line={"width": 1.2},
marker={"size": 6},
mode="lines+markers",
showlegend=False, row=2, col=1)
fig.update_layout(hovermode="x")
fig.update_layout(title_text="simulation virus") # titre du plot
fig.update_layout(title_font_color='#EF553B',) # couleur du titre
plot(fig)
sizes[others_idx] += int(
round(df[(df.NUTZUNG_LEVEL2 == label)
& is_district].FLAECHE.sum()))
else:
labels_used.append(label)
sizes.append(
int(
round(df[(df.NUTZUNG_LEVEL2 == label)
& is_district].FLAECHE.sum())))
explode = list(0 for label in labels_used)
street_idx = labels_used.index('Straßenraum u. Parkplätze')
explode[street_idx] = 0.1
fig = go.Figure(data=[
go.Pie(labels=labels_used,
values=sizes,
pull=explode,
marker_colors=[label_colors[i] for i in labels_used])
])
fig.update_traces(hoverinfo='label+text',
text=[f'{size:,} Quadratmeter' for size in sizes],
textinfo='percent',
textfont_size=14)
fig.update_layout(legend=dict(
x=0, y=-1, traceorder="normal", xanchor='left', yanchor='bottom'))
fig.update_layout(autosize=True)
pio.write_html(fig,
file=str(district) + '/index.html',
auto_open=False,
include_plotlyjs="cdn") # , include_mathjax="cdn")
fig.show()
def virus_px():
#paramètres
nb_individu = 1000
variance_population = 5
rayon_contamination = 2
infectiosite = 0.7
p = 0.4
d = 0.2 #proba de décès
fig = go.Figure() #création de la figure
x, y = make_blobs(n_samples=nb_individu, centers=2, cluster_std=variance_population, shuffle=True) #dataset population
taille_pop = len(x)
# création des subplots - 'xy' pour des courbes et 'domain' pour des pies | colspan pour étendre un subplot sur 2 colonnes
fig = make_subplots(rows=6, cols=2,column_widths=[0.8, 0.2],specs=[[{'type':'xy'},{'type':'domain'}],[{'type':'xy'},{'type':'domain'}],[{'type':'xy'},{'type':'domain'}],[{'type':'xy'},{'type':'domain'}],[{'type':'xy'},{'type':'domain'}],[{'type':'xy', "colspan": 2},None]])
# initialisation des courbes finales
courbe_sains = []
courbe_infectes = []
courbe_immunises = []
courbe_deces = []
"1er infecté"
numero_infecte_1 = rd.randint(0, taille_pop) # au hasard un individu dans la population
coord_1er_infecte = [x[:, 0][numero_infecte_1], x[:, 1][numero_infecte_1]]
fig.add_trace(go.Scatter(x=x[:, 0],y=x[:, 1],mode="markers",marker=dict(color="Blue"),showlegend=False),1,1) # on trace les individus sains
fig.add_trace(go.Scatter(x=[x[:, 0][numero_infecte_1]],y=[x[:, 1][numero_infecte_1]],mode="markers",marker=dict(color="Red"),showlegend=False),1,1) # on trace l'individu infecté
"pie"
labels = ["sains","infectés","immunisés","décédés"]
fig.add_trace(go.Pie(labels=labels, values=[taille_pop-1,1,0,0],sort=False),1,2) # création du pie (graphe fromage)
fig.update_xaxes(showgrid=False, visible= False, row=1, col=1)
fig.update_yaxes(showgrid=False, visible= False, row=1, col=1)
#actualisation des courbes
courbe_sains.append(taille_pop - 1)
courbe_infectes.append(1)
courbe_immunises.append(0)
courbe_deces.append(0)
"1er vague"
coord_infectes = [] # cette liste sera implémentée des nouveaux cas
coord_sains = [] # liste des cas sains
for k in range(taille_pop):
if [x[:, 0][k], x[:, 1][k]] == coord_1er_infecte:
coord_infectes.append(coord_1er_infecte)
elif distance(coord_1er_infecte, [x[:, 0][k], x[:, 1][k]]) < rayon_contamination and chance_infecte(infectiosite):
fig.add_trace(go.Scatter(x=[x[:, 0][k]], y=[x[:, 1][k]], mode="markers", marker=dict(color="DarkOrange"), showlegend=False),2,1)
coord_infectes.append([x[:, 0][k], x[:, 1][k]])
else:
fig.add_trace(go.Scatter(x=[x[:, 0][k]], y=[x[:, 1][k]], mode="markers", marker=dict(color="Blue"), showlegend=False),2,1)
coord_sains.append([x[:, 0][k], x[:, 1][k]])
fig.add_trace(go.Scatter(x=[x[:, 0][numero_infecte_1]], y=[x[:, 1][numero_infecte_1]], mode="markers",marker=dict(color="Red"), showlegend=False),2,1)
fig.update_xaxes(showgrid=False, visible=False, row=1, col=1) # on supprime les axes
fig.update_yaxes(showgrid=False, visible=False, row=1, col=1)
"pie"
labels = ["sains","infectés","immunisés","décédés"]
fig.add_trace(go.Pie(values=[ len(coord_sains),len(coord_infectes),0,0], labels=labels,sort=False),2,2)
courbe_sains.append(len(coord_sains))
courbe_infectes.append(len(coord_infectes))
courbe_immunises.append(0)
courbe_deces.append(0)
"2e vague"
non_sains = []
coord_infectes1, coord_immunises = immuniser(coord_infectes, [], p)
coord_infectes, coord_deces = deces(coord_infectes1, [], coord_immunises, d)
for k in range(len(coord_infectes)):
for j in range(len(coord_sains)):
if distance(np.array(coord_infectes)[k, :], np.array(coord_sains)[j, :]) < rayon_contamination and list(np.array(coord_sains)[j, :]) not in coord_infectes:
coord_infectes.append(list(np.array(coord_sains)[j, :]))
non_sains.append(list(np.array(coord_sains)[j, :]))
coord_sains = remove_(coord_sains, non_sains)
if coord_sains != []:
fig.add_trace(go.Scatter(x=np.array(coord_sains)[:, 0], y=np.array(coord_sains)[:, 1], mode="markers", marker=dict(color="Blue"), showlegend=False),3,1)
if coord_infectes != []:
fig.add_trace(go.Scatter(x=np.array(coord_infectes)[:, 0], y=np.array(coord_infectes)[:, 1], mode="markers",marker=dict(color="Red"), showlegend=False),3,1)
if coord_immunises != []:
fig.add_trace(go.Scatter(x=np.array(coord_immunises)[:, 0], y=np.array(coord_immunises)[:, 1], mode="markers",marker=dict(color="Green"), showlegend=False),3,1)
if coord_deces != []:
fig.add_trace(go.Scatter(x=np.array(coord_deces)[:, 0], y=np.array(coord_deces)[:, 1], mode="markers",marker=dict(color="Purple"), showlegend=False),3,1)
fig.update_xaxes(showgrid=False, visible=False, row=2, col=1)
fig.update_yaxes(showgrid=False, visible=False, row=2, col=1)
"pie"
labels = ["sains","infectés","immunisés","décédés"]
fig.add_trace(go.Pie(values=[len(coord_sains),len(coord_infectes) ,len(coord_immunises), len(coord_deces)], labels=labels,sort=False),3,2)
courbe_sains.append(len(coord_sains))
courbe_infectes.append(len(coord_infectes))
courbe_immunises.append(len(coord_immunises))
courbe_deces.append(len(coord_deces))
"3e vague"
non_sains = []
coord_infectes1, coord_immunises = immuniser(coord_infectes, coord_immunises, p)
coord_infectes, coord_deces = deces(coord_infectes1, coord_deces, coord_immunises, d)
for k in range(len(coord_infectes)):
for j in range(len(coord_sains)):
if distance(np.array(coord_infectes)[k, :], np.array(coord_sains)[j, :]) < rayon_contamination and list(
np.array(coord_sains)[j, :]) \
not in coord_infectes and chance_infecte(infectiosite):
coord_infectes.append(list(np.array(coord_sains)[j, :]))
non_sains.append(list(np.array(coord_sains)[j, :]))
coord_sains = remove_(coord_sains, non_sains) # on enlève les individus sains qui sont maintenant infectés
if coord_sains != []:
fig.add_trace(go.Scatter(x=np.array(coord_sains)[:, 0], y=np.array(coord_sains)[:, 1], mode="markers", marker=dict(color="Blue"), showlegend=False),4,1)
if coord_infectes != []:
fig.add_trace(go.Scatter(x=np.array(coord_infectes)[:, 0], y=np.array(coord_infectes)[:, 1], mode="markers",marker=dict(color="Red"), showlegend=False),4,1)
if coord_immunises != []:
fig.add_trace(go.Scatter(x=np.array(coord_immunises)[:, 0], y=np.array(coord_immunises)[:, 1], mode="markers",marker=dict(color="Green"), showlegend=False),4,1)
if coord_deces != []:
fig.add_trace(go.Scatter(x=np.array(coord_deces)[:, 0], y=np.array(coord_deces)[:, 1], mode="markers",marker=dict(color="Purple"), showlegend=False),4,1)
fig.update_xaxes(showgrid=False, visible=False, row=3, col=1)
fig.update_yaxes(showgrid=False, visible=False, row=3, col=1)
"pie"
labels = ["sains","infectés","immunisés","décédés"]
fig.add_trace(go.Pie(values=[len(coord_sains),len(coord_infectes) ,len(coord_immunises), len(coord_deces)], labels=labels,sort=False),4,2)
courbe_sains.append(len(coord_sains))
courbe_infectes.append(len(coord_infectes))
courbe_immunises.append(len(coord_immunises))
courbe_deces.append(len(coord_deces))
"4e vague"
non_sains = []
coord_infectes1, coord_immunises = immuniser(coord_infectes, coord_immunises, p)
coord_infectes, coord_deces = deces(coord_infectes1, coord_deces, coord_immunises, d)
for k in range(len(coord_infectes)):
for j in range(len(coord_sains)):
if distance(np.array(coord_infectes)[k, :], np.array(coord_sains)[j, :]) < rayon_contamination and list(
np.array(coord_sains)[j, :]) not in \
coord_infectes and chance_infecte(infectiosite):
coord_infectes.append(list(np.array(coord_sains)[j, :]))
non_sains.append(list(np.array(coord_sains)[j, :]))
coord_sains = remove_(coord_sains, non_sains)
if coord_sains != []:
fig.add_trace(go.Scatter(x=np.array(coord_sains)[:, 0], y=np.array(coord_sains)[:, 1], mode="markers", marker=dict(color="Blue"), showlegend=False),5,1)
if coord_infectes != []:
fig.add_trace(go.Scatter(x=np.array(coord_infectes)[:, 0], y=np.array(coord_infectes)[:, 1], mode="markers",marker=dict(color="Red"), showlegend=False),5,1)
if coord_immunises != []:
fig.add_trace(go.Scatter(x=np.array(coord_immunises)[:, 0], y=np.array(coord_immunises)[:, 1], mode="markers",marker=dict(color="Green"), showlegend=False),5,1)
if coord_deces != []:
fig.add_trace(go.Scatter(x=np.array(coord_deces)[:, 0], y=np.array(coord_deces)[:, 1], mode="markers",marker=dict(color="Purple"), showlegend=False),5,1)
fig.update_xaxes(showgrid=False, visible=False, row=4, col=1)
fig.update_yaxes(showgrid=False, visible=False, row=4, col=1)
"pie"
labels = ["sains","infectés","immunisés","décédés"]
fig.add_trace(go.Pie(values=[len(coord_sains),len(coord_infectes) ,len(coord_immunises), len(coord_deces)], labels=labels,sort=False),5,2)
courbe_sains.append(len(coord_sains))
courbe_infectes.append(len(coord_infectes))
courbe_immunises.append(len(coord_immunises))
courbe_deces.append(len(coord_deces))
"courbes"
x_courbe = list(np.arange(0, len(courbe_sains)))
# on trace les courbes finales
fig.add_trace(go.Scatter(x=x_courbe,y=courbe_sains,marker=dict(color="Blue"), name="sain",showlegend=False),6,1)
fig.add_trace(go.Scatter(x=x_courbe,y=courbe_infectes,marker=dict(color="Red"), name="infecté",showlegend=False),6,1)
fig.add_trace(go.Scatter(x=x_courbe,y=courbe_immunises,marker=dict(color="Green"), name="immunisé", showlegend=False),6,1)
fig.add_trace(go.Scatter(x=x_courbe,y=courbe_deces,marker=dict(color="Black"),name="décédé",showlegend=False),6,1)
fig.update_traces(
hoverinfo="name+x+y", # affichage du curseur avec la souris
line={"width": 1.2},
marker={"size": 6},
mode="lines+markers",
showlegend=False, row=2, col=1)
fig.update_layout(hovermode="x")
plot(fig)
& (db2015.copy().drop(['iso3'], axis=1)['countryname'] == country1)]
if age_new == 'All':
table2 = db2015.copy().drop(
['iso3'], axis=1).rename(columns=dic_cor)[(db2015.copy().drop(
['iso3'], axis=1)['countryname'] == country2)]
else:
table2 = db2015.copy().drop(['iso3'], axis=1).rename(columns=dic_cor)[
(db2015.copy().drop(['iso3'], axis=1)['age'] == age_new)
& (db2015.copy().drop(['iso3'], axis=1)['countryname'] == country2)]
table1 = pd.DataFrame(table1.drop(['age'], axis=1).mean()).reset_index()
table2 = pd.DataFrame(table2.drop(['age'], axis=1).mean()).reset_index()
labels1 = table1['index']
values1 = table1[0]
fig_new1 = go.Figure(data=[
go.Pie(labels=labels1, values=values1, direction='clockwise', sort=False)
])
labels2 = table2['index']
values2 = table2[0]
fig_new2 = go.Figure(data=[
go.Pie(labels=labels2, values=values2, direction='clockwise', sort=False)
])
st.markdown(f"Nutrition in {country1}")
st.plotly_chart(fig_new1)
st.markdown(f"Nutrition in {country2}")
st.plotly_chart(fig_new2)
########################################################################################################################
def metrics_of_tweet(
df,
retweet_col='retweet',
conversation_id_col='conversation_id',
id_col='id',
retweet_id_col='retweet_id',
user_id_col='user_id',
user_rt_id_col='user_rt_id',
):
df = df.drop_duplicates(
subset=[conversation_id_col, id_col, retweet_id_col])
number_tweets = df.shape[0]
number_users = len(
set(i for i in list(df[user_id_col].unique()) +
list(df[user_rt_id_col].unique())))
number_tweets_orig = sum((df[conversation_id_col] == df[id_col])
& (df[retweet_col] == False))
number_answers = sum((df[conversation_id_col] != df[id_col])
& (df[retweet_col] == False))
number_retweets = sum(df[retweet_col] == True)
labels = ['Orig. Tweets', 'Answers', 'Retweets']
values = [number_tweets_orig, number_answers, number_retweets]
fig = go.Figure()
fig.add_trace(
go.Indicator(mode="number",
value=number_tweets,
domain={
'x': [0, 0.5],
'y': [0.75, 1]
},
title='Number of Tweets'))
fig.add_trace(
go.Indicator(mode="number",
value=number_users,
domain={
'x': [0, 0.5],
'y': [0.12, 0.3]
},
title='Number of Users'))
fig.add_trace(
go.Indicator(mode="gauge",
gauge={
'shape': "bullet",
'axis': {
'range': [None, number_tweets]
}
},
value=number_users,
domain={
'x': [0, 0.5],
'y': [0, 0.1]
}))
fig.add_trace(
go.Pie(labels=labels,
values=values,
textinfo='none',
hole=0.7,
domain={
'x': [0.65, 1],
'y': [0, 1]
},
title='Types of Tweets'))
fig.update_layout(
grid={
'rows': 1,
'columns': 1,
'pattern': "independent"
},
legend={
'x': 1,
'y': 0.5,
'orientation': 'v',
'yanchor': 'middle'
},
)
return fig
def getPlots(mm):
wordAxisText = [np.asarray(mc[0][1]), np.asarray(mcw[0])]
arrV = calcTicks(maxval, 6)
arrT = [str(int(abs(x))) for x in arrV]
pieM = go.Pie(values=[totalcount[0], totalcount[2]],
labels=[chatters[0].split()[0], chatters[1].split()[0]],
hole=0.4,
pull=0.01,
hovertemplate='%{label} %{percent}' +
'<br>%{value} messages</br><extra></extra>',
marker=dict(colors=chattercolor),
domain=dict(x=[0.77, 0.965], y=[0.075, 0.375]),
rotation=90,
textfont=dict(family='Roboto'))
pieW = go.Pie(values=[totalcount[1], totalcount[3]],
labels=[chatters[0].split()[0], chatters[1].split()[0]],
hole=0.4,
pull=0.01,
hovertemplate='%{label} %{percent}' +
'<br>%{value} words</br><extra></extra>',
marker=dict(colors=chattercolor),
domain=dict(x=[0.77, 0.965], y=[0.575, 0.875]),
rotation=90,
textfont=dict(family='Roboto'))
polH1 = go.Scatterpolar(cliponaxis=True,
connectgaps=True,
subplot='polar1',
hoveron="points",
name=chatters[0].split(' ')[0],
r=hourBuckets[mm],
theta=hours,
hovertemplate=chatters[0].split(' ')[0] + '<br>' +
dictionary[mm] + ': %{r}</br>' +
'Hour: %{theta}<extra></extra>',
fill='toself',
line=dict(color=chattercolor[0]))
polH2 = go.Scatterpolar(cliponaxis=True,
connectgaps=True,
subplot='polar1',
hoveron="points",
r=hourBuckets[mm + 2],
theta=hours,
hovertemplate=chatters[1].split(' ')[0] + '<br>' +
dictionary[mm] + ': %{r}</br>' +
'Hour: %{theta}<extra></extra>',
fill='toself',
customdata=['1:23pm'],
line=dict(color=chattercolor[1]))
polW1 = go.Scatterpolar(cliponaxis=True,
connectgaps=True,
subplot='polar2',
hoveron="points",
name=chatters[0],
r=weekdayBuckets[mm],
theta=weekdays,
hovertemplate=chatters[0].split(' ')[0] + '<br>' +
dictionary[mm] + ': %{r}</br>' +
'Day: %{theta}<extra></extra>',
fill='toself',
line=dict(color=chattercolor[0]))
polW2 = go.Scatterpolar(cliponaxis=True,
connectgaps=True,
subplot='polar2',
hoveron="points",
name=chatters[1],
r=weekdayBuckets[mm + 2],
theta=weekdays,
hovertemplate=chatters[1].split(' ')[0] + '<br>' +
dictionary[mm] + ': %{r}</br>' +
'Day: %{theta}<extra></extra>',
fill='toself',
line=dict(color=chattercolor[1]))
barL = go.Bar(y=mcw[0],
x=mc[0][1],
xaxis='x2',
yaxis='y2',
orientation='h',
text=-1 * wordAxisText[0].astype('int'),
hovertemplate=chatters[0].split(' ')[0] +
'<br>Word: %{y}</br>' + 'Count: %{text}<extra></extra>',
marker=dict(color=chattercolor[0]))
barR = go.Bar(y=mcw[0],
x=mc[1][1],
orientation='h',
xaxis='x2',
yaxis='y2',
text=wordAxisText[1].astype(str),
textposition='outside',
texttemplate=' %{y}',
hovertemplate=chatters[1].split(' ')[0] +
'<br>Word: %{y}</br>' + 'Count: %{x}<extra></extra>',
textfont=dict(family='Open Sans, light'),
marker=dict(color=chattercolor[1]))
layout = go.Layout(
autosize=True,
margin=dict(t=0, b=0, l=0, r=0, pad=0),
template='plotly_dark',
polar1=dict(domain=dict(x=[0.035, 0.23], y=[0.075, 0.375]),
radialaxis=dict(visible=True,
showticklabels=False,
showline=False,
angle=45,
tickangle=45,
tickmode='auto',
nticks=4,
tickfont=dict(size=10, family='Roboto')),
angularaxis=dict(rotation=90,
direction='clockwise',
type='category',
tickfont=dict(family='Roboto'))),
polar2=dict(domain=dict(x=[0.035, 0.23], y=[0.575, 0.875]),
radialaxis=dict(visible=True,
showticklabels=False,
showline=False,
angle=45,
tickangle=45,
tickmode='auto',
nticks=5,
tickfont=dict(size=8, family='Roboto')),
angularaxis=dict(rotation=90,
direction='clockwise',
type='category',
tickfont=dict(family='Roboto'))),
xaxis2=dict(domain=[0.25, 0.75],
tickfont=dict(family='Roboto'),
position=0,
anchor='free',
range=[-maxval * 1.1, maxval * 1.1],
uirevision='n',
tickvals=arrV,
ticktext=arrT,
nticks=6),
yaxis2=dict(domain=[0, 0.93],
tickfont=dict(family='Roboto'),
showticklabels=False,
type='category'),
showlegend=False,
barmode='overlay',
transition={
'duration': 500,
'ordering': "traces first"
},
annotations=[
dict(text=dictionary[mm] + '<br>per weekday',
showarrow=False,
font=dict(size=35),
xref="paper",
yref="paper",
xanchor='center',
x=0.1328,
y=1,
height=100,
width=250,
align='center'),
dict(text=dictionary[mm] + '<br>per hour',
showarrow=False,
font=dict(size=35),
xref="paper",
yref="paper",
xanchor='center',
x=0.1328,
y=0.45,
height=500,
width=250,
align='center'),
dict(text='Most used words',
showarrow=False,
font=dict(size=40),
xref="paper",
yref="paper",
xanchor='center',
x=0.5,
y=1,
width=400),
dict(text='Words<br>per person',
showarrow=False,
font=dict(size=35),
xref="paper",
yref="paper",
xanchor='center',
x=0.8672,
y=1,
height=100,
width=250,
align='center'),
dict(text='Messages<br>per person',
showarrow=False,
font=dict(size=35),
xref="paper",
yref="paper",
xanchor='center',
x=0.8672,
y=0.45,
height=500,
width=250,
align='center')
])
if totalcount[mm] >= totalcount[mm + 2]:
data = [pieM, pieW, polH1, polH2, polW1, polW2, barL, barR]
else:
data = [pieM, pieW, polH2, polH1, polW2, polW1, barL, barR]
fig = go.Figure(data=data, layout=layout)
return fig
# it shows the difference of booking cancellations for th total amount of book canceled or not and the percentage(resort and city hotels)
resort_hotel = hotel_booked[hotel_booked["hotel"] == "Resort Hotel"]
city_hotel = hotel_booked[hotel_booked["hotel"] == "City Hotel"]
cancel_reso = pd.DataFrame(resort_hotel["is_canceled"].value_counts())
cancel_reso.rename(columns={"is_canceled": "booking_cancellations"}, index =({0: "No Canceled", 1:"Yes Canceled"}), inplace=True)
cancel_reso["Status"] = cancel_reso.index
cancel_city = pd.DataFrame(city_hotel["is_canceled"].value_counts())
cancel_city.rename(columns={"is_canceled": "booking_cancellations"}, index =({0: "No Canceled", 1:"Yes Canceled"}), inplace=True)
cancel_city["Status"] = cancel_city.index
# make a pie chart to show the differece book canceled for those hotels
fig = make_subplots(rows=1, cols=2, specs=[[{'type':'domain'}, {'type':'domain'}]], subplot_titles = ["City Hotel", "Resort Hotel"])
fig.add_trace(go.Pie(values = cancel_city["booking_cancellations"], labels = cancel_city["Status"]),1,1)
fig.add_trace(go.Pie(values = cancel_reso["booking_cancellations"], labels = cancel_reso["Status"]),1,2)
fig.update_traces(textposition='inside', textinfo='value+percent+label')
fig.update_layout(title_text = "Type Of Booking Cancellations For City Hotel And Resort Hotel")
fig.show()
# scatter plot between reservation_status and lead_time
px.scatter(hotel_booked, x='reservation_status', y='lead_time', color='reservation_status', opacity=0.1)
# add new feature engineering from existing adr column
# make a new column called total overnight cost in each hotel for guest
hotel_booked["adr_pp"] =hotel_booked["adr"] / (hotel_booked["adults"] + hotel_booked["children"])
room_guest = hotel_booked[hotel_booked["reservation_status"]== 0]
room_cost = room_guest[["hotel", "adr_pp", "reserved_room_type"]].sort_values("reserved_room_type")
plt.figure(figsize= (13,9))
import plotly.graph_objects as go labels = ['Oxygen','Hydrogen','Carbon_Dioxide','Nitrogen'] values = [4500, 2500, 1053, 500] fig = go.Figure(data=[go.Pie(labels=labels, values=values)]) fig.show()
def reddit_radios(n_clicks, subreddit):
if n_clicks > 0:
#return 'You have selected "{}"'.format(subreddit)
#Define function to pull up historical Reddit post information
def load_results(lower_bound_timestamp, upper_bound_timestamp,
target_result_size, target_subreddit,
score_threshold):
headline_collection = set()
reddit_data_url = f"https://api.pushshift.io/reddit/submission/search/?after={lower_bound_timestamp}&before={upper_bound_timestamp}&sort_type=score&sort=desc&subreddit={target_subreddit}&limit={target_result_size}&score={score_threshold}"
try:
with urllib.request.urlopen(reddit_data_url) as url:
data = json.loads(url.read().decode())
for submission in data['data']:
headline_collection.add(submission['title'])
return headline_collection
except urllib.error.HTTPError as e:
print(e.__dict__)
return set()
except urllib.error.URLError as e:
print(e.__dict__)
return set()
# Get Reddit posts
headlines = set()
time_now = datetime.datetime.now()
limit_delta = 7
limit_lower_delta = 6
result_size = 1000
score_limit = ">0"
for i in range(0, 8):
previous_timestamp = int(
(time_now - datetime.timedelta(days=limit_delta)).timestamp())
current_timestamp = int(
(time_now -
datetime.timedelta(days=limit_lower_delta)).timestamp())
full_collection = load_results(previous_timestamp,
current_timestamp, result_size,
subreddit, score_limit)
headlines = headlines.union(full_collection)
limit_delta = limit_delta - 1
limit_lower_delta = limit_lower_delta - 1
display.clear_output()
# Calculate polarity to get the sentiment
sia = SentimentIntensityAnalyzer()
results = []
for line in headlines:
pol_score = sia.polarity_scores(line)
pol_score['headline'] = line
results.append(pol_score)
#Convert the results to a dataframe
df = pd.DataFrame.from_records(results)
#Label the results accordingly
df['label'] = 'Neutral'
df.loc[df['compound'] > 0.1, 'label'] = 'Positive'
df.loc[df['compound'] < -0.1, 'label'] = 'Negative'
#Create Pie Chart
labels = df['label'].value_counts().index
values = df['label'].value_counts()
fig = go.Figure(data=[go.Pie(labels=labels, values=values)])
reddit_pie = html.Div([dcc.Graph(figure=fig)])
# Clean the text
allWords = ' '.join([rdf for rdf in df['headline']])
allWords_lower = allWords.lower()
stop = set(stopwords.words('english') + list(string.punctuation))
new_stopwords = ['...', '``', "''", '’', "'s", "n't"]
new_stopwords_list = stop.union(new_stopwords)
text_tokens = nltk.word_tokenize(allWords_lower)
text_no_stop_words_punct = [
t for t in text_tokens
if t not in new_stopwords_list and t not in string.punctuation
]
filtered_string = (" ").join(text_no_stop_words_punct)
# Convert the long string to a dictionary with frequency counts.
def word_count(str):
counts = dict()
words = str.split()
for word in words:
if word in counts:
counts[word] += 1
else:
counts[word] = 1
return counts
reddit_wordcloud = (word_count(filtered_string))
# Create Word Cloud
wc = WordCloud().generate_from_frequencies(
frequencies=reddit_wordcloud)
wc_img = wc.to_image()
with BytesIO() as buffer:
wc_img.save(buffer, 'png')
img2 = base64.b64encode(buffer.getvalue()).decode()
#Display Pie Chart and Word Cloud
reddit_results = html.Div([
html.Div(dcc.Graph(id='graph1', figure=fig),
style={
'width': '49%',
'display': 'inline-block'
}),
html.Div(children=[
html.Img(src="data:image/png;base64," + img2,
style={
'height': '50%',
'width': '50%'
})
],
style={
'width': '49%',
'display': 'block',
'textAlign': 'center'
}),
])
return reddit_results
import plotly.graph_objects as go
from dash.dependencies import Input, Output
import load_data as ld
import site_info as si
import log_writer as lw
site_top_df = ld.load_data_site()
site_top_df.sort_values('Визиты', inplace=True)
site_label1 = site_top_df.sort_values(
'Посетители', ascending=False).reset_index().drop('index', axis=1)
el_b_df = ld.load_data_eb()
fig_site_top3 = go.Figure(data=[
go.Pie(labels=el_b_df['site_page'],
values=el_b_df['Глубина просмотра'],
hole=.3)
])
fig_site_top3.update_layout(
title_text='Глубина просмотра раздела "Электронный бюджет"',
autosize=True,
piecolorway=[
'#26205b', '#3257af', '#c8abd5', '#f9c5d8', '#b83e74', '#8d0837',
'#9456ef'
],
paper_bgcolor='#ebecf1',
plot_bgcolor='#ebecf1')
# ------------------------------------- start load data block ------------------------------------------------------
etsp_df = ld.LoadEtspData()
fig_3 = make_subplots(rows=1, cols=len(choice), subplot_titles=choice)
if breakdown_type == 'Bar plot':
for i in range(1):
for j in range(len(choice)):
fig_3.add_trace(
go.Bar(x=plot_sentiment(choice[j]).Sentiment, y=plot_sentiment(choice[j]).Tweets, showlegend=False),
row=i+1, col=j+1
)
fig_3.update_layout(height=600, width=800)
st.plotly_chart(fig_3)
else:
fig_3 = make_subplots(rows=1, cols=len(choice), specs=[[{'type':'domain'}]*len(choice)], subplot_titles=choice)
for i in range(1):
for j in range(len(choice)):
fig_3.add_trace(
go.Pie(labels=plot_sentiment(choice[j]).Sentiment, values=plot_sentiment(choice[j]).Tweets, showlegend=True),
i+1, j+1
)
fig_3.update_layout(height=600, width=800)
st.plotly_chart(fig_3)
st.sidebar.subheader("Breakdown airline by sentiment")
choice = st.sidebar.multiselect('Pick airlines', ('US Airways','United','American','Southwest','Delta','Virgin America'), key=0)
if len(choice) > 0:
choice_data = data[data.airline.isin(choice)]
fig_0 = px.histogram(
choice_data, x='airline', y='airline_sentiment',
histfunc='count', color='airline_sentiment',
facet_col='airline_sentiment', labels={'airline_sentiment':'tweets'},
height=600, width=800)
st.plotly_chart(fig_0)
def update_figure_user(start_date_user, end_date_user, choosen_month,
choosen_week, choice_type_period):
if choice_type_period == 'm':
period_choice = True
week_choice = True
month_choice = False
lw.log_writer(f'User choice "month = {choosen_month}"')
if int(choosen_month) > 1:
etsp_prev_filt_df = etsp_df[etsp_df['month_open'] == (
int(choosen_month) - 1)]
sue_prev_filt_df = sue_df[sue_df['month_open'] == (
int(choosen_month) - 1)]
osp_prev_filt_df = osp_df[osp_df['month_open'] == (
int(choosen_month) - 1)]
else:
etsp_prev_filt_df = etsp_df[etsp_df['month_open'] == 12]
sue_prev_filt_df = sue_df[sue_df['month_open'] == 12]
osp_prev_filt_df = osp_df[osp_df['month_open'] == 12]
etsp_filtered_df = etsp_df[etsp_df['month_open'] == int(choosen_month)]
sue_filtered_df = sue_df[sue_df['month_open'] == int(choosen_month)]
osp_filtered_df = osp_df[osp_df['month_open'] == int(choosen_month)]
sue_incidents_filtered_df = sue_incidents_df[
sue_incidents_df['month_open'] == int(choosen_month)]
print(sue_incidents_filtered_df)
start_date_metrika = ld.GetMonthPeriod(ld.current_year,
choosen_month)[0]
end_date_metrika = ld.GetMonthPeriod(ld.current_year, choosen_month)[1]
filtered_metrika_df = si.get_site_info(start_date_metrika,
end_date_metrika)
elif choice_type_period == 'p':
period_choice = False
week_choice = True
month_choice = True
lw.log_writer(
f'User choice "range period start = {start_date_user}, end = {end_date_user}"'
)
if int(start_date_user[5:7]) > 1:
etsp_prev_filt_df = etsp_df[etsp_df['month_open'] == (
int(start_date_user[5:7]) - 1)]
sue_prev_filt_df = sue_df[sue_df['month_open'] == (
int(start_date_user[5:7]) - 1)]
osp_prev_filt_df = osp_df[osp_df['month_open'] == (
int(start_date_user[5:7]) - 1)]
else:
etsp_prev_filt_df = etsp_df[etsp_df['month_open'] == 12]
sue_prev_filt_df = sue_df[sue_df['month_open'] == 12]
osp_prev_filt_df = osp_df[osp_df['month_open'] == 12]
etsp_filtered_df = etsp_df[(etsp_df['start_date'] >= start_date_user)
& (etsp_df['start_date'] <= end_date_user)]
sue_filtered_df = sue_df[(sue_df['start_date'] >= start_date_user)
& (sue_df['start_date'] <= end_date_user)]
osp_filtered_df = osp_df[(osp_df['start_date'] >= start_date_user)
& (osp_df['start_date'] <= end_date_user)]
sue_incidents_filtered_df = sue_incidents_df[
(sue_incidents_df['Дата обращения'] >= start_date_user)
& (sue_incidents_df['Дата обращения'] <= end_date_user)]
start_date_metrika = start_date_user
end_date_metrika = end_date_user
filtered_metrika_df = si.get_site_info(start_date_metrika,
end_date_metrika)
else:
period_choice = True
week_choice = False
month_choice = True
lw.log_writer(
f'User choice "week = {choosen_week} ({ld.GetPeriod(ld.current_year, choosen_week)})"'
)
if int(choosen_week) > 1:
etsp_prev_filt_df = etsp_df[etsp_df['week_open'] == (
int(choosen_week) - 1)]
sue_prev_filt_df = sue_df[sue_df['week_open'] == (
int(choosen_week) - 1)]
osp_prev_filt_df = osp_df[osp_df['week_open'] == (
int(choosen_week) - 1)]
else:
etsp_prev_filt_df = etsp_df[etsp_df['week_open'] == 52]
sue_prev_filt_df = sue_df[sue_df['week_open'] == 52]
osp_prev_filt_df = osp_df[osp_df['week_open'] == 52]
etsp_filtered_df = etsp_df[etsp_df['week_open'] == int(choosen_week)]
sue_filtered_df = sue_df[sue_df['week_open'] == int(choosen_week)]
osp_filtered_df = osp_df[osp_df['week_open'] == int(choosen_week)]
sue_incidents_filtered_df = sue_incidents_df[
sue_incidents_df['week_open'] == int(choosen_week)]
start_date_metrika = ld.GetPeriod(ld.current_year, choosen_week,
's')[0]
end_date_metrika = ld.GetPeriod(ld.current_year, choosen_week, 's')[1]
filtered_metrika_df = si.get_site_info(start_date_metrika,
end_date_metrika)
etsp_count_tasks = etsp_filtered_df['count_task'].sum()
sue_count_tasks = sue_filtered_df['count_task'].sum()
osp_count_tasks = osp_filtered_df['count_task'].sum()
etsp_prev_count_tasks = etsp_prev_filt_df['count_task'].sum()
sue_prev_count_tasks = sue_prev_filt_df['count_task'].sum()
osp_prev_count_tasks = osp_prev_filt_df['count_task'].sum()
etsp_avg_time = ld.CountMeanTime(etsp_filtered_df)
sue_avg_time = ld.CountMeanTime(sue_filtered_df)
osp_avg_time = ld.CountMeanTime(osp_filtered_df)
visits = str(int(filtered_metrika_df['visits'][0]))
users = str(int(filtered_metrika_df['users'][0]))
pageviews = str(int(filtered_metrika_df['pageviews'][0]))
bounceRate = ''.join(
[str(round(filtered_metrika_df['bounceRate'][0], 2)), "%"])
pageDepth = str(round(filtered_metrika_df['pageDepth'][0], 2))
avgVisitDurSec = str(
dt.timedelta(seconds=round(
filtered_metrika_df['avgVisitDurationSeconds'][0], 0)))[2:]
site_stat_data = [{
'Визиты': visits,
'Посетители': users,
'Просмотры': pageviews,
'Отказы': bounceRate,
'Глубина просмотра': pageDepth,
'Время на сайте': avgVisitDurSec
}]
fig_support = go.Figure(
go.Bar(y=[etsp_count_tasks, sue_count_tasks, osp_count_tasks],
x=['ЕЦП', 'СУЭ', 'ОСП'],
base=0,
marker=dict(color=['#a92b2b', '#37a17c', '#a2d5f2']),
text=[etsp_count_tasks, sue_count_tasks, osp_count_tasks],
textposition='auto'))
fig_support.update_layout(autosize=True,
legend=dict(orientation="h",
yanchor="bottom",
y=0.2,
xanchor="right",
x=0.5),
paper_bgcolor='#ebecf1',
plot_bgcolor='#ebecf1')
fig_support.update_xaxes(ticks="inside", tickson="boundaries")
total_curr_tasks = etsp_count_tasks + sue_count_tasks + osp_count_tasks
total_prev_tasks = etsp_prev_count_tasks + sue_prev_count_tasks + osp_prev_count_tasks
diff_tasks = total_curr_tasks - total_prev_tasks
if diff_tasks > 0:
style_tasks = {'font-size': '2em', 'color': 'green'}
diff_tasks = '+ ' + str(diff_tasks)
elif diff_tasks == 0:
style_tasks = {'font-size': '2em'}
diff_tasks = str(diff_tasks)
else:
style_tasks = {'font-size': '2em', 'color': 'red'}
diff_tasks = str(diff_tasks)
total_tasks = ''.join([str(total_curr_tasks), ' ( ', diff_tasks, ' )'])
total_curr_users = len(etsp_filtered_df['user'].unique()) + len(
sue_filtered_df['user'].unique()) + len(
osp_filtered_df['user'].unique())
total_prev_users = len(etsp_prev_filt_df['user'].unique()) + len(
sue_prev_filt_df['user'].unique()) + len(
osp_prev_filt_df['user'].unique())
diff_users = total_curr_users - total_prev_users
if diff_users > 0:
style_users = {'font-size': '2em', 'color': 'green'}
diff_users = '+ ' + str(diff_users)
elif diff_users == 0:
style_users = {'font-size': '2em'}
diff_users = str(diff_users)
else:
style_users = {'font-size': '2em', 'color': 'red'}
diff_users = str(diff_users)
total_users = ''.join([str(total_curr_users), ' ( ', diff_users, ' )'])
labels_figure_support = ["ЕЦП", "СУЭ", "ОСП"]
values_figure_support = [
etsp_filtered_df['count_task'].sum(),
sue_filtered_df['count_task'].sum(),
osp_filtered_df['count_task'].sum()
]
colors = ['#a92b2b', '#37a17c', '#a2d5f2']
fig = go.Figure(
go.Pie(labels=labels_figure_support,
values=values_figure_support,
marker_colors=colors))
fig.update_traces(hoverinfo="label+percent+name")
fig.update_layout(paper_bgcolor='#ebecf1', showlegend=True)
etsp_top_user_filtered_df = ld.TopUser(etsp_filtered_df)
sue_top_user_filtered_df = ld.TopUser(sue_filtered_df)
if len(sue_incidents_filtered_df) > 0:
style_data = dict(width='20%', backgroundColor='#ff847c')
tooltip_data = [{
column: {
'value': str(value),
'type': 'markdown'
}
for column, value in row.items()
} for row in sue_incidents_filtered_df.to_dict('records')]
else:
style_data = dict(width='20%', backgroundColor='#c4fbdb')
sue_incidents_filtered_df = ld.NoIncidents()
tooltip_data = sue_incidents_filtered_df.to_dict('records')
return (period_choice, month_choice, week_choice, fig_support, total_tasks,
style_tasks, total_users, style_users, etsp_avg_time,
sue_avg_time, osp_avg_time, fig,
sue_incidents_filtered_df.to_dict('records'), style_data,
etsp_top_user_filtered_df.to_dict('records'),
sue_top_user_filtered_df.to_dict('records'), site_stat_data,
tooltip_data)
def Aff_pies_func(input):
aff_data = input
if sum(aff_data.Count) < 2:
pi_plural = "PI"
else:
pi_plural = "PIs"
colours = np.array([""] * len(aff_data["PI_aff"]), dtype=object)
for i in aff_data["PI_aff"]:
colours[
np.where(aff_data["PI_aff"] == i)
] = FACILITY_USER_AFFILIATION_COLOUR_OFFICIAL_ABB[str(i)]
fig = go.Figure(
go.Pie(
# aff_data,
values=aff_data["Count"],
labels=aff_data["PI_aff"],
hole=0.6,
# color=aff_data["PI_aff"],
marker=dict(colors=colours, line=dict(color="#000000", width=1)),
direction="clockwise",
sort=True,
)
)
# fig = px.pie(
# aff_data,
# values="Count",
# names="PI_aff",
# hole=0.6,
# color="PI_aff",
# color_discrete_map=FACILITY_USER_AFFILIATION_COLOUR_OFFICIAL_ABB,
# )
fig.update_traces(
textposition="outside",
texttemplate="%{label} (%{percent:.1%f})",
# the :.1%f does to 1 decimal place. do .0 to round to whole numbers. HOWEVER! whole numbers tend to give 0% as a value. Wouldnt recommend
) # textinfo="percent+label")
fig.update_layout(
margin=dict(
l=100, r=100, b=100, t=100
), # original values l=200, r=200 b=100 t=300
font=dict(size=34), # 36 works for most
annotations=[
dict(
showarrow=False,
text="{} {}".format(sum(aff_data.Count), pi_plural),
font=dict(size=50), # should work for all centre bits
x=0.5,
y=0.5,
)
],
showlegend=False,
width=1000,
height=1000,
autosize=False,
)
if not os.path.isdir("Plots/Aff_Pies/"):
os.mkdir("Plots/Aff_Pies/")
if sum(aff_data.Count) > 0:
fig.write_image(
"Plots/Aff_Pies/{}_{}_affs.svg".format(
input["Unit"][input["Unit"].first_valid_index()],
input["Year"][input["Year"].first_valid_index()],
)
)
else:
print(
"Warning: not all unit year combinations have data - check whether this is expected"
)
cursor.execute("""
Select Count(flower_id)/(select count(*) from sepal), spicies_name from sepal
LEFT join Vid_irisa on sepal.species_id=Vid_irisa.species_id
group by spicies_name
""")
name = []
count = []
for row in cursor:
print("Вид ириса ", str(row[1]) + " Количество в выборке: " + str(row[0]) )
name += [row[1]]
count += [row[0]]
pie = go.Pie(labels=name, values=count)
ohyt = py.plot([pie])
"...............................Creating DashBoar..........................."
my_dboard = dashboard.Dashboard()
vovin_diagram = fileId_from_url(ohyt3)
voin_kryg = fileId_from_url(ohyt2)
vovini_tochki = fileId_from_url(ohyt)
import plotly.graph_objects as go
import numpy as np
np.random.seed(42)
# declaring size of arr
size = 7
x = [f'Product {i}' for i in range(size)]
y = np.random.randint(low=0, high=100, size=size)
# creating a Pie Chart
fig = go.Figure(data=[go.Pie(labels=x, values=y)])
# Adjusting width and height of the image
fig.layout.template = 'plotly_dark'
# To display labels with the percentage
fig.update_traces(textposition='inside', textinfo='percent+label')
fig.update_layout(title='Pie Chart',
xaxis_title='X Axis Title',
yaxis_title='Y Axis Title',
autosize=False,
width=600,
height=600,
margin=dict(l=50, r=50, b=100, t=100, pad=4))
fig.show()
def plot_stock_data(ticker="AAPL"):
import dash
import dash_core_components as dcc
import dash_html_components as html
import plotly.graph_objects as go
from plotly.offline import plot
from plotly.subplots import make_subplots
import pandas as pd
from datetime import datetime
from dash.dependencies import Input, Output
import json
import plotly.express as px
ticker_list, ticker_names = get_data.get_tickers_list_SP500()
ticker_list = [{
"label": name,
"value": ticker
} for name, ticker in zip(ticker_names, ticker_list)]
df = pd.read_csv(f"tickers_data/{ticker}.csv")
fig = make_subplots(specs=[[{"secondary_y": True}]])
fig.add_trace(go.Candlestick(x=df["datetime"],
open=df["open"],
high=df["high"],
low=df["low"],
close=df["close"]),
secondary_y=False)
fig.add_trace(go.Bar(x=df["datetime"], y=df["volume"], opacity=1),
secondary_y=False)
fig.layout.yaxis2.showgrid = False
fig.update_layout(title=f"{ticker}", clickmode="event+select")
optimal_weights = portfolio_optimization()
#optimal_weights = pd.DataFrame({"names": optimal_weights.keys(), "values": optimal_weights.values()})
#print(optimal_weights.head())
portfolio_fig = make_subplots()
portfolio_fig.add_trace(
go.Pie(labels=list(optimal_weights.keys()),
values=list(optimal_weights.values())))
# DASH APP
app = dash.Dash("Stock Data")
'''
"data": [{"x": df["datetime"], "open": df["open"], "high": df["high"], "low": df["low"],
"close": df["close"],
"name":ticker,
"type": "candlestick"
},
{"x": df["datetime"], "y": df["volume"], "type": "bar"}
]
'''
app.layout = html.Div([
dcc.Graph(id="basic-interactions", figure=fig),
html.Div(children=[
dcc.Dropdown(id="input-stock", options=ticker_list, value='AAPL')
]),
dcc.Graph(id="portfolio-weights", figure=portfolio_fig)
])
@app.callback(Output('basic-interactions', 'figure'),
Input('input-stock', 'value'))
def change_plot(ticker):
df = pd.read_csv(f"tickers_data/{ticker}.csv")
fig = make_subplots(specs=[[{"secondary_y": True}]])
fig.add_trace(go.Candlestick(x=df["datetime"],
open=df["open"],
high=df["high"],
low=df["low"],
close=df["close"]),
secondary_y=True)
fig.add_trace(go.Bar(x=df["datetime"], y=df["volume"]),
secondary_y=False)
fig.layout.yaxis2.showgrid = False
fig.update_layout(title=f"{ticker}", clickmode="event+select")
return fig
app.run_server(debug=True)
