1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
|
# Copyright (c) 2017 Cisco and/or its affiliates.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at:
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Algorithms to generate tables.
"""
import logging
from string import replace
from errors import PresentationError
from utils import mean, stdev, relative_change
def generate_tables(spec, data):
"""Generate all tables specified in the specification file.
:param spec: Specification read from the specification file.
:param data: Data to process.
:type spec: Specification
:type data: InputData
"""
logging.info("Generating the tables ...")
for table in spec.tables:
try:
eval(table["algorithm"])(table, data)
except NameError:
logging.error("The algorithm '{0}' is not defined.".
format(table["algorithm"]))
logging.info("Done.")
def table_details(table, input_data):
"""Generate the table(s) with algorithm: table_detailed_test_results
specified in the specification file.
:param table: Table to generate.
:param input_data: Data to process.
:type table: pandas.Series
:type input_data: InputData
"""
logging.info(" Generating the table {0} ...".
format(table.get("title", "")))
# Transform the data
data = input_data.filter_data(table)
# Prepare the header of the tables
header = list()
for column in table["columns"]:
header.append('"{0}"'.format(str(column["title"]).replace('"', '""')))
# Generate the data for the table according to the model in the table
# specification
job = table["data"].keys()[0]
build = str(table["data"][job][0])
try:
suites = input_data.suites(job, build)
except KeyError:
logging.error(" No data available. The table will not be generated.")
return
for suite_longname, suite in suites.iteritems():
# Generate data
suite_name = suite["name"]
table_lst = list()
for test in data[job][build].keys():
if data[job][build][test]["parent"] in suite_name:
row_lst = list()
for column in table["columns"]:
try:
col_data = str(data[job][build][test][column["data"].
split(" ")[1]]).replace('"', '""')
if column["data"].split(" ")[1] in ("vat-history",
"show-run"):
col_data = replace(col_data, " |br| ", "",
maxreplace=1)
col_data = " |prein| {0} |preout| ".\
format(col_data[:-5])
row_lst.append('"{0}"'.format(col_data))
except KeyError:
row_lst.append("No data")
table_lst.append(row_lst)
# Write the data to file
if table_lst:
file_name = "{0}_{1}{2}".format(table["output-file"], suite_name,
table["output-file-ext"])
logging.info(" Writing file: '{}'".format(file_name))
with open(file_name, "w") as file_handler:
file_handler.write(",".join(header) + "\n")
for item in table_lst:
file_handler.write(",".join(item) + "\n")
logging.info(" Done.")
def table_performance_improvements(table, input_data):
"""Generate the table(s) with algorithm: table_performance_improvements
specified in the specification file.
:param table: Table to generate.
:param input_data: Data to process.
:type table: pandas.Series
:type input_data: InputData
"""
def _write_line_to_file(file_handler, data):
"""Write a line to the .csv file.
:param file_handler: File handler for the csv file. It must be open for
writing text.
:param data: Item to be written to the file.
:type file_handler: BinaryIO
:type data: list
"""
line_lst = list()
for item in data:
if isinstance(item["data"], str):
line_lst.append(item["data"])
elif isinstance(item["data"], float):
line_lst.append("{:.1f}".format(item["data"]))
elif item["data"] is None:
line_lst.append("")
file_handler.write(",".join(line_lst) + "\n")
logging.info(" Generating the table {0} ...".
format(table.get("title", "")))
# Read the template
file_name = table.get("template", None)
if file_name:
try:
tmpl = _read_csv_template(file_name)
except PresentationError:
logging.error(" The template '{0}' does not exist. Skipping the "
"table.".format(file_name))
return None
else:
logging.error("The template is not defined. Skipping the table.")
return None
# Transform the data
data = input_data.filter_data(table)
# Prepare the header of the tables
header = list()
for column in table["columns"]:
header.append(column["title"])
# Generate the data for the table according to the model in the table
# specification
tbl_lst = list()
for tmpl_item in tmpl:
tbl_item = list()
for column in table["columns"]:
cmd = column["data"].split(" ")[0]
args = column["data"].split(" ")[1:]
if cmd == "template":
try:
val = float(tmpl_item[int(args[0])])
except ValueError:
val = tmpl_item[int(args[0])]
tbl_item.append({"data": val})
elif cmd == "data":
job = args[0]
operation = args[1]
data_lst = list()
for build in data[job]:
try:
data_lst.append(float(build[tmpl_item[0]]["throughput"]
["value"]) / 1000000)
except (KeyError, TypeError):
# No data, ignore
continue
if data_lst:
tbl_item.append({"data": eval(operation)(data_lst)})
else:
tbl_item.append({"data": None})
elif cmd == "operation":
operation = args[0]
try:
nr1 = float(tbl_item[int(args[1])]["data"])
nr2 = float(tbl_item[int(args[2])]["data"])
if nr1 and nr2:
tbl_item.append({"data": eval(operation)(nr1, nr2)})
else:
tbl_item.append({"data": None})
except (IndexError, ValueError):
logging.error("No data for {0}".format(tbl_item[1]["data"]))
tbl_item.append({"data": None})
continue
else:
logging.error("Not supported command {0}. Skipping the table.".
format(cmd))
return None
tbl_lst.append(tbl_item)
# Sort the table according to the relative change
tbl_lst.sort(key=lambda rel: rel[-1]["data"], reverse=True)
# Create the tables and write them to the files
file_names = [
"{0}_ndr_top{1}".format(table["output-file"], table["output-file-ext"]),
"{0}_pdr_top{1}".format(table["output-file"], table["output-file-ext"]),
"{0}_ndr_low{1}".format(table["output-file"], table["output-file-ext"]),
"{0}_pdr_low{1}".format(table["output-file"], table["output-file-ext"])
]
for file_name in file_names:
logging.info(" Writing the file '{0}'".format(file_name))
with open(file_name, "w") as file_handler:
file_handler.write(",".join(header) + "\n")
for item in tbl_lst:
if "ndr_top" in file_name \
and "ndr" in item[1]["data"] \
and item[-1]["data"] >= 10.0:
_write_line_to_file(file_handler, item)
elif "pdr_top" in file_name \
and "pdr" in item[1]["data"] \
and item[-1]["data"] >= 10.0:
_write_line_to_file(file_handler, item)
elif "ndr_low" in file_name \
and "ndr" in item[1]["data"] \
and item[-1]["data"] < 10.0:
_write_line_to_file(file_handler, item)
elif "pdr_low" in file_name \
and "pdr" in item[1]["data"] \
and item[-1]["data"] < 10.0:
_write_line_to_file(file_handler, item)
logging.info(" Done.")
def _read_csv_template(file_name):
"""Read the template from a .csv file.
:param file_name: Name / full path / relative path of the file to read.
:type file_name: str
:returns: Data from the template as list (lines) of lists (items on line).
:rtype: list
:raises: PresentationError if it is not possible to read the file.
"""
try:
with open(file_name, 'r') as csv_file:
tmpl_data = list()
for line in csv_file:
tmpl_data.append(line[:-1].split(","))
return tmpl_data
except IOError as err:
raise PresentationError(str(err), level="ERROR")
|
