def get_info(self, timestamp=None):
model = Requirement(self.env)
met = RequirementMetric(model)
predicate = None
results = met.pmi(predicate, timestamp)
if len(results) == 0:
self.no_results()
pmis = []
for pairing in results.keys():
cur_fp = Fp(self.env, id=pairing[0])['name']
cur_obj = Object(self.env, id=pairing[1])['name']
pmis.append((cur_fp, cur_obj, '%.3f' % results[pairing]))
self.req.hdf['pmis'] = pmis
def get_info( self, timestamp=None ):
model = Requirement(self.env)
met = RequirementMetric(model)
results = met.entropy(timestamp)
if results is None:
self.no_results()
else:
total_entropy = results[0]
avg_entropy = results[1]
components_entropies = results[2]
req_entropies = results[3]
fp_entropies = results[4]
object_entropies = results[5]
# Ease division below
if total_entropy == 0:
total_entropy = 1;
reqs = []
for req, entropy in req_entropies.iteritems():
my_fp = Fp(self.env, id=req[1])['name']
my_obj = Object(self.env, id=req[2])['name']
reqs.append({'name': '<'+req[0]+' '+my_fp+' '+my_obj+'>',
'link': self.req.href.requirement(req[0]+
'-'+my_fp+'-'+my_obj),
'entropy': '%.3f' % entropy})
components = []
for comp, entropy in components_entropies.iteritems():
components.append({'name': comp,
'percent': '%.1f' % (100 * entropy / total_entropy)})
self.req.hdf['graph_path'] = self.req.href.requirements()+'/graph/'
self.req.hdf['reqs'] = sorted(reqs, lambda x,y: cmp(float(y['entropy']), float(x['entropy'])))
self.req.hdf['components'] = sorted(components, lambda x,y: cmp(x['name'], y['name']))
def entropy_graph(self):
"""Creates a graph of entropy over time for requirements
This returns an image with each requirement's entropy over
time shown over the course of the project. If a project is old,
or there are a lot of requirements, this can be a time consuming
process.
"""
# Image generation prelude.
fig = self._new_image((4,4))
canvas = FigureCanvasAgg(fig)
ax = fig.add_axes([0.1, 0.2, 0.85, 0.75])
# Set up our time range from oldest time to now/newest.
metric = RequirementMetric(Requirement(self.env))
start_time = metric.model.get_timestamp_first_entity()
end_time = metric.model.get_timestamp_latest_req_reqchange_milestone()
current_time = int(time.time())
if current_time > end_time:
end_time = current_time
#create the list of timestamps and make labels.
times = []
timestamp = end_time
# We'll use two week increments for now to reduce
# delay while loading.
seconds_in_unit = (60 * 60 * 24 * 7 * 2)
while timestamp > start_time:
times.append(timestamp)
timestamp -= seconds_in_unit
times.reverse()
labels = [time.strftime("%b %d '%y",time.gmtime(timestamp)) \
for timestamp in times]
# Create the coordinates lists for graphing
coords = {}
i = 0
for timestamp in times:
i = i + 1
if timestamp > current_time:
break;
entropy_data = metric.entropy(timestamp)
if entropy_data:
_,_,_, req_entropies, _, _ = entropy_data
for key in req_entropies.keys():
if not coords.has_key(key):
coords[key] = [(i, req_entropies[key])]
else:
coords[key].append((i, req_entropies[key]))
biggest = []
# Now we can actually graph them all
for req in coords.keys():
x = [x[0] for x in coords[req]]
y = [y[1] for y in coords[req]]
biggest.append(max(y))
ax.plot(x,y,'k-')
# Add the milestone markers.
milestones = Requirement(self.env).get_milestones()
x = []
for (_, due) in milestones:
if due == 0:
continue
x.append( float(due - times[0]) / float( seconds_in_unit))
height = int(float(max(biggest)) + 1.5)
ax.vlines(x, 0, height,colors='r')
# Label and shape the graph
ax.set_xticks(range(0, len(times), 1))
ax.set_xticklabels(labels)
ax.set_xlim(0, len(times))
setp(ax.get_xticklabels(),'rotation', 80, fontsize=6)
ax.set_xlabel('Time in two-week increments', fontsize=6)
ax.set_yticks(arange(0,height, 1))
ax.set_ylim(0, height)
setp(ax.get_yticklabels(), fontsize=6)
ax.set_ylabel("Entropy", fontsize=6)
return canvas
