def genBoxPlot(plotTitle, srcPath, svgName, plotStartDate):
dirs = os.listdir(srcPath)
dictHoursWeekday = {0:[],1:[],2:[],3:[],4:[],5:[],6:[],7:[],8:[],9:[],\
10:[],11:[],12:[],13:[],14:[],15:[],16:[],17:[],18:[],19:[],\
20:[],21:[],22:[],23:[]}
dictHoursWeekend = {0:[],1:[],2:[],3:[],4:[],5:[],6:[],7:[],8:[],9:[],\
10:[],11:[],12:[],13:[],14:[],15:[],16:[],17:[],18:[],19:[],\
20:[],21:[],22:[],23:[]}
filterPath = srcPath + 'filter.txt'
filterList = open(filterPath, 'r').read().split('\n')
for file in dirs:
if file.endswith('.pcap'):
if (file not in filterList) and (datetime.datetime.strptime(
file[0:10], '%Y-%m-%d').date() >= plotStartDate):
#print file + ',',
#print file[0:10] + ',',
#print datetime.datetime.strptime(file[0:10], '%Y-%m-%d').strftime('%a') + ',',
#print file[15:17] + ',',
statinfo = os.stat(srcPath + file)
#print '{}{}'.format(statinfo.st_size, ','),
#print float(statinfo.st_size)/1073741824
if datetime.datetime.strptime(file[0:10], '%Y-%m-%d').strftime('%a') != 'Sat'\
and datetime.datetime.strptime(file[0:10], '%Y-%m-%d').strftime('%a') != 'Sun':
dictHoursWeekday[int(file[15:17])].append(
float(statinfo.st_size) / 1073741824)
else:
dictHoursWeekend[int(file[15:17])].append(
float(statinfo.st_size) / 1073741824)
#else:
#print 'file in list'
print plotTitle
box_plot = pygal.Box(config,
style=custom_style,
title='Weekday ' + plotTitle)
for hr in sorted(dictHoursWeekday):
print hr,
box_plot.add(hr, dictHoursWeekday[hr])
box_plot.render_to_file('/mnt/sniffs/www/Network/' + svgName +
'Weekday.svg')
print
box_plot = pygal.Box(config,
style=custom_style,
title='Weekend ' + plotTitle)
for hr in sorted(dictHoursWeekend):
print hr,
box_plot.add(hr, dictHoursWeekend[hr])
box_plot.render_to_file('/mnt/sniffs/www/Network/' + svgName +
'Weekend.svg')
print
return
def candlesGraph(candles):
box_plot = pygal.Box(show_legend=False, style=darken_style)
box_plot.title = '1-Month Candlestick Graph (USD)'
# [::-1] to reverse date order
count = 0
for row in candles[-31:-1]:
box_plot.add(row['timestamp'][0:10], [
float(row['low']),
float(row['high']),
float(row['open']),
float(row['close'])
])
count += 1
if count == 30:
break
box_plot.render()
path = os.path.abspath(os.path.dirname(__file__)) + '/static/images/'
filename = 'candles.svg'
url = path + filename
box_plot.render_to_file(url)
return box_plot
def generate_box_chart_security(libraries):
box_chart = pygal.Box(range=(0, 1),
title='Percentage Of Total Security Related Issues',
x_title='Total Security Issues',
y_title='Percentage',
x_label_rotation=-45,
style=invis_style)
count = 0
unsorted_list = []
for library in libraries:
for issue in library.issue_data:
if issue.security_issue == 'Yes':
count += 1
unsorted_list.append(
(count / len(library.issue_data), library.name, count))
count = 0
sorted_list = sorted(unsorted_list,
key=lambda library: library[0],
reverse=False)
labels = []
for library in sorted_list:
box_chart.add(library[1], library[0])
labels.append(library[1] + ': ' + str(library[2]))
box_chart.x_labels = labels
return box_chart
def graph():
_charts = [
pygal.Line(),
pygal.Bar(),
pygal.Histogram(),
pygal.XY(),
pygal.Pie(),
pygal.Radar(),
pygal.Box(),
pygal.Dot(),
pygal.Funnel(),
pygal.SolidGauge(),
pygal.Gauge(),
pygal.Pyramid(),
pygal.Treemap()
]
charts = []
for chart in _charts:
chart.title = '% Change Coolness of programming languages over time.'
chart.x_labels = ['2011', '2012', '2013', '2014', '2015', '2016']
chart.add('Python', [15, 31, 89, 200, 356, 900])
chart.add('Java', [15, 45, 76, 80, 91, 95])
chart.add('C++', [5, 51, 54, 102, 150, 201])
chart.add('All others combined!', [5, 15, 21, 55, 92, 105])
charts.append(chart.render_data_uri())
return render_template('part2/graph.html',
charts=charts,
root_path=root_path)
def generate_box_chart_last_discussed(libraries):
box_chart = pygal.Box(title='Days Since Last Discussed On Stack Overflow',
x_title='Total Discussions',
y_title='',
x_label_rotation=-45,
style=invis_style)
now = datetime.now()
unsorted_list = []
for library in libraries:
if library.last_discussed_on_stack_overflow[0] != None:
f_date = date(library.last_discussed_on_stack_overflow[0].year,
library.last_discussed_on_stack_overflow[0].month,
library.last_discussed_on_stack_overflow[0].day)
l_date = date(now.year, now.month, now.day)
time_from_release_all = l_date - f_date
time_from_release = time_from_release_all.days
unsorted_list.append(
(time_from_release, time_from_release, library.name,
library.last_discussed_on_stack_overflow[1]))
else:
unsorted_list.append(([], 0, library.name,
library.last_discussed_on_stack_overflow[1]))
sorted_list = sorted(unsorted_list,
key=lambda library: library[1],
reverse=False)
labels = []
for library in sorted_list:
box_chart.add(library[2], library[0])
labels.append(library[2] + ': ' + str(library[3]))
box_chart.x_labels = labels
return box_chart
def make_graph():
"""make graph in section center"""
#open worksheet
book = open_workbook('C:/projet_psit.xlsx')
sheet = book.sheet_by_index(0) #code select sheet
primary = [sheet.cell(1, col_index).value for col_index in range(1, 13)]
junior = [sheet.cell(2, col_index).value for col_index in range(1, 13)]
senior = [sheet.cell(3, col_index).value for col_index in range(1, 13)]
vocational = [sheet.cell(4, col_index).value for col_index in range(1, 13)]
high_vocational = [
sheet.cell(5, col_index).value for col_index in range(1, 13)
]
undergraduate = [
sheet.cell(6, col_index).value for col_index in range(1, 13)
]
#make graph
line_chart = pygal.Box() #รูปแบบของ graph
line_chart.title = sheet.cell(0, 0).value
year = []
for i in ["2556", "2557", "2558"]:
for j in range(1, 5):
year.append(i + "/" + str(j))
line_chart.x_labels = map(str, year)
line_chart.add(sheet.cell(1, 0).value, primary)
line_chart.add(sheet.cell(2, 0).value, junior)
line_chart.add(sheet.cell(3, 0).value, senior)
line_chart.add(sheet.cell(4, 0).value, vocational)
line_chart.add(sheet.cell(5, 0).value, high_vocational)
line_chart.add(sheet.cell(6, 0).value, undergraduate)
line_chart.render_to_file('education.svg')
def draw_box(self, imdir, x_title=None):
ds = self.req.durations
graph_x_title = '{} iterations'.format(len(list(ds.values())[0]))
if x_title:
graph_x_title = x_title
box = pygal.Box(x_title=graph_x_title,
y_title='Response time in sec',
style=STYLE)
box.title = '{}'.format(self.req.type.name)
for name in self.req.durations.keys():
box.add(name, self.req.durations[name])
img = os.path.join(imdir, '{}_box'.format(self.req.name))
if self.svg:
img = '{}.{}'.format(img, 'svg')
box.render_to_file(img)
else:
img = '{}.{}'.format(img, 'png')
box.render_to_png(img)
self.imgs.append(os.path.join('graph', os.path.basename(img)))
def plot_normalized_box(array1, array2, label1='', label2=''):
import numpy as np
box = pygal.Box()
box.title = 'Jormun Bench Box Comparaison (in ms)'
box.add('Time Ratio: {}/{}'.format(label2, label1),
np.array(array2) / np.array(array1))
box.render_to_file('output_box.svg')
def render_box(subject, main_title):
box_chart = pygal.Box()
for i in range(4):
if i == 0:
title_mean = 'Input Disc'
title_dev = 'Input Color'
elif i == 1:
title_mean = 'E-GAN Disc'
title_dev = 'E-GAN Color'
elif i == 2:
title_mean = 'DeepLPF Disc'
title_dev = 'DeepLPF Color'
else: # 3
title_mean = 'CUD-NET Disc'
title_dev = 'CUD-NET Color'
insert_box_chart(title_mean, box_chart, subject.disc_mean[i],
subject.disc_dev[i])
insert_box_chart(title_dev, box_chart, subject.color_mean[i],
subject.color_dev[i])
box_chart.add('trash', [0.5, 4.3]) # set the threshold of output image.
box_chart.render_to_file(main_title + '.svg')
def aggr_plot():
params = parseReq(request)
day_start = params.get('day_start')
day_end = params.get('day_end')
key = params.get('key')
aggregate = params.get('aggregate')
if key and aggregate:
if day_start:
day_start = datetime.datetime.fromisoformat(day_start)
else:
day_start = datetime.datetime(2020, 3, 1)
if day_end:
day_end = datetime.datetime.fromisoformat(day_end)
else:
day_end = datetime.datetime.today()
entries = analysis.getAllEntriesOfDayRange(day_start, day_end)
try:
results = analysis.aggregateMultiple(entries, key, aggregate)
except ValueError as e:
print(e)
abort(400)
results = analysis.padMissingDays(results)
if aggregate == "all" and not type(key) is list:
# make a box plot
graph = pygal.Box(x_label_rotation=35, truncate_label=-1)
graph.title = "distribution of " + listToVerboseStr(
key) + " over time."
graph.x_labels = [x["timestamp"] for x in results]
for day in results:
# if not day["values"][key+"_"+aggregate][0]:
# graph.add(day["timestamp"],None, allow_interruptions=True)
# else:
graph.add(day["timestamp"],
day["values"][key + "_" + aggregate],
allow_interruptions=True)
elif aggregate == "all" or "all" in aggregate:
abort(400)
else:
graph = pygal.Line(x_label_rotation=35, truncate_label=-1)
graph.title = listToVerboseStr(
aggregate) + " of " + listToVerboseStr(key) + " over time."
graph.x_labels = [x["timestamp"] for x in results]
if not type(key) is list:
key = [key]
if not type(aggregate) is list:
aggregate = [aggregate] * len(key)
for k, a in zip(key, aggregate):
data = [x["values"][k + "_" + a] for x in results]
graph.add(k + " " + a, data, allow_interruptions=True)
graph_data = graph.render_response()
return graph_data
else:
abort(400)
def box():
box_plot = py.Box()
box_plot.title = 'V8 benchmark results'
box_plot.add('Chrome', [6395, 8212, 7520, 7218, 12464, 1660, 2123, 8607])
box_plot.add('Firefox', [7473, 8099, 11700, 2651, 6361, 1044, 3797, 9450])
box_plot.add('Opera', [3472, 2933, 4203, 5229, 5810, 1828, 9013, 4669])
box_plot.add('IE', [43, 41, 59, 79, 144, 136, 34, 102])
return Response(response=box_plot.render(), content_type='image/svg+xml')
def __init__(self, **kwargs):
self.data = {}
self.chart = pygal.Box(**kwargs)
self.chart.style = DefaultStyle(tooltip_font_size=14)
self.chart.legend_at_bottom = True
self.chart.box_mode = "tukey"
self.chart.legend_at_bottom_columns = 3
def plot_normalized_box(data):
box = pygal.Box()
box.title = 'Jormun Bench Box'
for label, array in data:
box.add(label, array)
box.render_to_file('output_box.svg')
def show_player(player_id):
player = Player.query.filter_by(id=player_id).one()
plot = pygal.Box()
for deal in ['six', 'seven', 'eight', 'nine', 'ten', 'score']:
plot.add(deal, [getattr(game, deal) for game in player.scores])
return render_template('player.html',
player=player,
plot=plot.render(disable_xml_declaration=True))
def show(data):
seleccionados = data.getSeleccionados()
#chart = pygal.Box(box_mode="pstdev") # stander desviation
chart = pygal.Box()
chart.title = data.getTitle()
#chart.x_labels = data.getEje(data.getSeleccionEjeX(), 0)
for selec in seleccionados:
chart.add(selec, data.getEje(data.getSeleccionEjeY(), selec))
chart.render_to_file('output/box_pygal.html')
def boxplot(args):
import pygal
benchmark_results = __plot(args, use_mean=False)
box_plot = pygal.Box()
box_plot.title = 'Language benchmark results'
[box_plot.add(lang, results) for lang, results in benchmark_results]
print("Opening table in web browser...")
box_plot.render_to_file('./result/chart.svg')
print("Done")
def plot_box_plot(self, flats, quarter):
data = self.query_distribution_data(flats, quarter)
box_plot = pygal.Box(box_mode="stdev", style=style)
box_plot.title = f'Distribution of median resale prices in the Q{quarter} (All Time)'
box_plot.x_labels = flats
for flat in flats:
box_plot.add(flat, data[flat])
box_plot.render_to_file(
Plot.generate_plot_name(
f'resale_price_distribution_box_Q{quarter}_all_time'))
def plot(stock_data):
'plot'
data = stock_data['dataset']['data']
box_plot = pygal.Box()
box_plot.title = stock_data['dataset']['name']
lowest = 999999
for daily_data in data:
box_plot.add(
daily_data[0],
[daily_data[1], daily_data[2], daily_data[3], daily_data[4]])
lowest = min(lowest, daily_data[3])
box_plot.zero = int(lowest)
return box_plot.render_data_uri()
def render_chart(environ, start_response):
stats = bp_perf.stats
chart_name = pop_path_info(environ)
if chart_name not in stats:
start_response('404 Not Found', [('content-type', 'text/plain; charset=ascii')])
return [b"Chart not found"]
else:
data = stats[chart_name]
chart = pygal.Box(box_mode='tukey', width=1200, height=600)
chart.title = chart_name
for bp, data in data.items():
chart.add(bp, data)
start_response('200 OK', [('content-type', 'image/svg+xml')])
return [chart.render()]
def generate_box_chart_backwards_compatibility(libraries):
box_chart = pygal.Box(title='Number Of Breaking Changes Per Version',
x_title='Total Number Of Versions',
y_title='',
x_label_rotation=-45,
style=invis_style)
labels = []
for library in libraries:
box_chart.add(library.name, library.backward_compatibilty)
labels.append(library.name + ': ' +
str(len(library.backward_compatibilty)))
box_chart.x_labels = labels
return box_chart
def csv_to_boxplot(input_path, output_path, column_id=None, title=None):
df = pd.read_csv(input_path)
df.set_index('Id', inplace=True)
box_plot = pygal.Box()
if title:
box_plot.title = title
if column_id:
box_plot.add(column_id, df[column_id])
else:
for column in df:
box_plot.add(column, df[column])
box_plot.render_to_file(output_path)
def make_boxplots(alldistpropspertext, boxplotfile):
for feature in alldistpropspertext.columns[:-1].values:
currentboxplotfile = boxplotfile + "_" + feature + ".svg"
distribution = alldistpropspertext.loc[:,[feature,"label"]]
distributionspertext = pd.groupby(distribution, "label")
boxplot = pygal.Box(style=threeway_style,
title = "Verteilung für \'" + feature + "\'",
x_title = "Partitionen",
y_title = "Verteilung der Anteile",
legend_at_bottom=True,
legend_at_bottom_columns = 3,
)
for name, group in distributionspertext:
groupprops = list(group.loc[:,feature])
boxplot.add(name, groupprops)
boxplot.render_to_file(currentboxplotfile)
def boxplot(args):
import pygal
benchmark_results = __plot(args, use_mean=False)
box_plot = pygal.Box()
box_plot.title = 'Language benchmark results\n({})'.format(
__get_additional_title_info(args))
[box_plot.add(lang, results) for lang, results in benchmark_results]
result_data = {lang: results for lang, results in benchmark_results}
result_data['_metadata'] = __get_run_metadata(args, 'boxplot')
__render_and_save(box_plot, result_data)
print("Done")
def makeChart(term):
chart = pygal.Box(range=(-1, 1))
chart.title = 'News Sentiments for Term \'' + term + '\''
cnn = NewsSentiment.Cnn()
fox = NewsSentiment.Fox()
threads = [
threader.makeThread(generateSentiment, (chart, cnn, term)),
threader.makeThread(generateSentiment, (chart, fox, term))
]
threader.joinThreads(threads)
filename = term + '.png'
chart.render_to_png(filename)
webbrowser.open(filename)
def box_fruit_2013():
"""Show the product prices in 2013"""
box_plot = pygal.Box()
box_plot.title = 'Fruit prices in 2013'
box_plot.add('Kiwi, 1 kg', [
1.90, 1.97, 2.00, 2.07, 2.32, 2.45, 3.16, 4.38, 4.73, 5.12, 5.96, 6.19
])
box_plot.add('Apple, 1 kg', [
2.25, 2.33, 2.37, 2.41, 2.56, 2.58, 2.72, 2.96, 3.24, 3.60, 3.81, 4.12
])
box_plot.add('Banana, 1 kg', [
2.53, 2.54, 2.55, 2.56, 2.64, 2.65, 2.67, 2.67, 2.67, 2.68, 2.78, 2.80
])
box_plot.add('Lettuce, 1 kg', [
2.55, 2.61, 2.77, 2.85, 3.07, 3.56, 3.65, 3.74, 4.23, 6.56, 6.73, 9.18
])
box_plot.render_to_file('./Plotting/box_fruit_2013.svg')
return box_plot
def generate_box_chart_issue_response_time(libraries):
box_chart = pygal.Box(title='Days Taken To Respond To Issue',
x_title='Total Issues Responsed To',
y_title='Days',
x_label_rotation=-45,
style=invis_style)
all_response_times = []
for library in libraries:
response_times = []
for issue in library.issue_data:
if issue.issue_closing_date != None:
response_times.append(issue.time_to_response)
box_chart.add(library.name, response_times)
all_response_times.append(library.name + ': ' +
str(len(response_times)))
box_chart.x_labels = all_response_times
return box_chart
def plot(self):
single_factor_df = self._single_factor_df.dropna().sort_values(
self.factor_name, ascending=False)
# 画因子原始分布图
line_chart = pygal.Bar()
line_chart.title = self.factor_name
line_chart.x_labels = single_factor_df.index.values
single_factor_values = single_factor_df.values[:, 0]
line_chart.add(self.factor_name, single_factor_values)
line_chart.render_to_file('output\\' + self.factor_name +
'_chart_original.svg')
single_factor_df = self.winsorize(2.0).dropna().sort_values(
self.factor_name, ascending=False)
# 画因子去极值分布图
line_chart = pygal.Bar()
line_chart.title = self.factor_name
line_chart.x_labels = single_factor_df.index.values
single_factor_values = single_factor_df.values[:, 0]
single_factor_values[single_factor_values < np.percentile(
single_factor_values, 2.0)] = np.percentile(
single_factor_values, 2.0) # 去极小值
single_factor_values[single_factor_values > np.percentile(
single_factor_values, 98.0)] = np.percentile(
single_factor_values, 98.0) # 去极大值
line_chart.add(self.factor_name, single_factor_values)
line_chart.render_to_file('output\\' + self.factor_name +
'_chart_winsorize.svg')
# 统计个行业指标信息
single_factor_df[self.factor_name] = list(
single_factor_values) # 引如去极值的因子
factor_industry_mean = single_factor_df.groupby('industry').mean()
factor_industry_std = single_factor_df.groupby('industry').std()
# 行业统计信息画图
box_plot = pygal.Box(height=1000, width=1500, legend_box_size=20)
box_plot.title = 'industry statitics of ' + self.factor_name
for industry, group in single_factor_df.groupby('industry'):
box_plot.add(industry, group[self.factor_name].values)
box_plot.render_to_file('output\\' + self.factor_name +
'_chart_box.svg')
def make_pcboxplot(transformed, variance, groups, idnos, pcboxplotfile):
print("----make_pcboxplot")
values = []
for i in range(0,391):
value = transformed[i][0]
values.append(value)
data = pd.DataFrame({"group" : groups, "value" : values, "idnos" : idnos})
# print(data.head())
data = data.groupby("group")
boxplot = pygal.Box(style=threeway_style,
title="Verteilung der Texte",
# x_title="X",
y_title="PC 1",
legend_at_bottom=True,
print_labels = True,
legend_at_bottom_columns=3)
for name, group in data:
groupscores = list(group.loc[:, "value"])
boxplot.add(name, groupscores)
boxplot.render_to_file(pcboxplotfile)
return data
def create_review_length_boxplot(reviews, filename, box_mode='tukey'):
"""
Creates a boxplot chart with five entries that show the distribution of the review lengths for all possible scores
Reviews longer than 1500 words are ignored in this example
Chart documentation: http://www.pygal.org/en/latest/documentation/types/box.html
:param reviews: list of review dictionaries
:param filename: string
:param box_mode: type of boxchart, e.g. None, 'tukey', 'stdv'
"""
one_star_review_lengths = []
two_star_review_lengths = []
three_star_review_lengths = []
four_star_review_lengths = []
five_star_review_lengths = []
for review in reviews:
score = int(review['review/score'])
review_length = len(review['review/text'].split(' '))
if review_length > 1500: # ignore some outliers
continue
if score == 1:
one_star_review_lengths.append(review_length)
elif score == 2:
two_star_review_lengths.append(review_length)
elif score == 3:
three_star_review_lengths.append(review_length)
elif score == 4:
four_star_review_lengths.append(review_length)
elif score == 5:
five_star_review_lengths.append(review_length)
box_plot = pygal.Box(box_mode=box_mode)
box_plot.title = 'Review Lengths by Review Score'
box_plot.add('1 Star Reviews', one_star_review_lengths)
box_plot.add('2 Star Reviews', two_star_review_lengths)
box_plot.add('3 Star Reviews', three_star_review_lengths)
box_plot.add('4 Star Reviews', four_star_review_lengths)
box_plot.add('5 Star Reviews', five_star_review_lengths)
box_plot.x_labels = ['1 Star', '2 Stars', '3 Stars', '4 Stars', '5 Stars']
box_plot.render_to_file(filename)
def generate_box_chart_release_frequency(libraries):
box_chart = pygal.Box(title='Days Between Releases',
x_title='Total Releases',
y_title='Days',
x_label_rotation=-45,
style=invis_style)
all_release_times = []
release_tuples = []
for library in libraries:
release_times = []
for i in range(len(library.release_frequency) - 1):
f_date = date(library.release_frequency[i].year,
library.release_frequency[i].month,
library.release_frequency[i].day)
l_date = date(library.release_frequency[i + 1].year,
library.release_frequency[i + 1].month,
library.release_frequency[i + 1].day)
time_to_release_all = l_date - f_date
time_to_release = time_to_release_all.days
release_times.append(time_to_release)
avg_release_time = sum(release_times) / len(release_times)
release_tuples.append((release_times, avg_release_time,
len(release_times), library.name))
# box_chart.add(library.name, release_times)
# all_release_times.append(library.name + ': ' + str(len(release_times)))
sorted_release_tuples = sorted(release_tuples,
key=lambda release: release[1],
reverse=False)
for release_tuple in sorted_release_tuples:
box_chart.add(release_tuple[3], release_tuple[0])
all_release_times.append(release_tuple[3] + ': ' +
str(release_tuple[2]))
box_chart.x_labels = all_release_times
return box_chart
