Viewing file:  stats.py (18.37 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
# - coding: utf-8 -
# Copyright (C) 2008-2009 Toms Bauģis <toms.baugis at gmail.com>
# This file is part of Project Hamster.
# Project Hamster is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
# Project Hamster is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with Project Hamster. If not, see <http://www.gnu.org/licenses/>.
import pygtk
pygtk.require('2.0')
import os
import time
import datetime as dt
import calendar
from itertools import groupby
from gettext import ngettext
import gtk, gobject
import pango
import stuff, charting, graphics, widgets
from configuration import runtime, conf
from hamster.i18n import C_
class Stats(object):
def __init__(self, parent = None):
self._gui = stuff.load_ui_file("stats.ui")
self.report_chooser = None
self.window = self.get_widget("stats_window")
self.parent = parent# determine if app should shut down on close
self.stat_facts = None
day_start = conf.get("day_start_minutes")
day_start = dt.time(day_start / 60, day_start % 60)
self.timechart = widgets.TimeChart()
self.timechart.day_start = day_start
self.get_widget("explore_everything").add(self.timechart)
self.get_widget("explore_everything").show_all()
runtime.dispatcher.add_handler('activity_updated', self.after_fact_update)
runtime.dispatcher.add_handler('day_updated', self.after_fact_update)
self.init_stats()
self.window.set_position(gtk.WIN_POS_CENTER)
self._gui.connect_signals(self)
self.window.show_all()
self.stats()
def init_stats(self):
self.stat_facts = runtime.storage.get_facts(dt.date(1970, 1, 1), dt.date.today())
if not self.stat_facts or self.stat_facts[-1]["start_time"].year == self.stat_facts[0]["start_time"].year:
self.get_widget("explore_controls").hide()
else:
by_year = stuff.totals(self.stat_facts,
lambda fact: fact["start_time"].year,
lambda fact: 1)
year_box = self.get_widget("year_box")
class YearButton(gtk.ToggleButton):
def __init__(self, label, year, on_clicked):
gtk.ToggleButton.__init__(self, label)
self.year = year
self.connect("clicked", on_clicked)
all_button = YearButton(C_("years", "All").encode("utf-8"),
None,
self.on_year_changed)
year_box.pack_start(all_button)
self.bubbling = True # TODO figure out how to properly work with togglebuttons as radiobuttons
all_button.set_active(True)
self.bubbling = False # TODO figure out how to properly work with togglebuttons as radiobuttons
years = sorted(by_year.keys())
for year in years:
year_box.pack_start(YearButton(str(year), year, self.on_year_changed))
year_box.show_all()
self.chart_category_totals = charting.HorizontalBarChart(value_format = "%.1f",
bars_beveled = False,
max_bar_width = 20,
legend_width = 70)
self.get_widget("explore_category_totals").add(self.chart_category_totals)
self.chart_weekday_totals = charting.HorizontalBarChart(value_format = "%.1f",
bars_beveled = False,
max_bar_width = 20,
legend_width = 70)
self.get_widget("explore_weekday_totals").add(self.chart_weekday_totals)
self.chart_weekday_starts_ends = charting.HorizontalDayChart(bars_beveled = False,
animate = False,
max_bar_width = 20,
legend_width = 70)
self.get_widget("explore_weekday_starts_ends").add(self.chart_weekday_starts_ends)
self.chart_category_starts_ends = charting.HorizontalDayChart(bars_beveled = False,
animate = False,
max_bar_width = 20,
legend_width = 70)
self.get_widget("explore_category_starts_ends").add(self.chart_category_starts_ends)
#ah, just want summary look just like all the other text on the page
class CairoText(graphics.Area):
def __init__(self, fontsize = 10):
graphics.Area.__init__(self)
self.text = ""
self.fontsize = fontsize
def set_text(self, text):
self.text = text
self.redraw_canvas()
def on_expose(self):
# now for the text - we want reduced contrast for relaxed visuals
fg_color = self.get_style().fg[gtk.STATE_NORMAL].to_string()
if self.colors.is_light(fg_color):
label_color = self.colors.darker(fg_color, 80)
else:
label_color = self.colors.darker(fg_color, -80)
default_font = pango.FontDescription(gtk.Style().font_desc.to_string())
default_font.set_size(self.fontsize * pango.SCALE)
self.layout.set_font_description(default_font)
#self.context.set_source_rgb(0,0,0)
self.layout.set_markup(self.text)
self.layout.set_width((self.width) * pango.SCALE)
self.context.move_to(0,0)
self.set_color(label_color)
self.context.show_layout(self.layout)
self.explore_summary = CairoText()
self.get_widget("explore_summary").add(self.explore_summary)
self.get_widget("explore_summary").show_all()
def stats(self, year = None):
facts = self.stat_facts
if year:
facts = filter(lambda fact: fact["start_time"].year == year,
facts)
if not facts or (facts[-1]["start_time"] - facts[0]["start_time"]) < dt.timedelta(days=6):
self.get_widget("statistics_box").hide()
#self.get_widget("explore_controls").hide()
label = self.get_widget("not_enough_records_label")
if not facts:
label.set_text(_("""There is no data to generate statistics yet.
A week of usage would be nice!"""))
else:
label.set_text(_(u"Collecting data — check back after a week has passed!"))
label.show()
return
else:
self.get_widget("statistics_box").show()
self.get_widget("explore_controls").show()
self.get_widget("not_enough_records_label").hide()
# All dates in the scope
durations = [(fact["start_time"], fact["delta"]) for fact in facts]
self.timechart.draw(durations, facts[0]["date"], facts[-1]["date"])
# Totals by category
categories = stuff.totals(facts,
lambda fact: fact["category"],
lambda fact: fact['delta'].seconds / 60 / 60.0)
category_keys = sorted(categories.keys())
categories = [categories[key] for key in category_keys]
self.chart_category_totals.plot(category_keys, categories)
# Totals by weekday
weekdays = stuff.totals(facts,
lambda fact: (fact["start_time"].weekday(),
fact["start_time"].strftime("%a")),
lambda fact: fact['delta'].seconds / 60 / 60.0)
weekday_keys = sorted(weekdays.keys(), key = lambda x: x[0]) #sort
weekdays = [weekdays[key] for key in weekday_keys] #get values in the order
weekday_keys = [key[1] for key in weekday_keys] #now remove the weekday and keep just the abbreviated one
self.chart_weekday_totals.plot(weekday_keys, weekdays)
split_minutes = 5 * 60 + 30 #the mystical hamster midnight
# starts and ends by weekday
by_weekday = {}
for date, date_facts in groupby(facts, lambda fact: fact["start_time"].date()):
date_facts = list(date_facts)
weekday = (date_facts[0]["start_time"].weekday(),
date_facts[0]["start_time"].strftime("%a"))
by_weekday.setdefault(weekday, [])
start_times, end_times = [], []
for fact in date_facts:
start_time = fact["start_time"].time()
start_time = start_time.hour * 60 + start_time.minute
if fact["end_time"]:
end_time = fact["end_time"].time()
end_time = end_time.hour * 60 + end_time.minute
if start_time < split_minutes:
start_time += 24 * 60
if end_time < start_time:
end_time += 24 * 60
start_times.append(start_time)
end_times.append(end_time)
if start_times and end_times:
by_weekday[weekday].append((min(start_times), max(end_times)))
for day in by_weekday:
by_weekday[day] = (sum([fact[0] for fact in by_weekday[day]]) / len(by_weekday[day]),
sum([fact[1] for fact in by_weekday[day]]) / len(by_weekday[day]))
min_weekday = min([by_weekday[day][0] for day in by_weekday])
max_weekday = max([by_weekday[day][1] for day in by_weekday])
weekday_keys = sorted(by_weekday.keys(), key = lambda x: x[0])
weekdays = [by_weekday[key] for key in weekday_keys]
weekday_keys = [key[1] for key in weekday_keys] # get rid of the weekday number as int
# starts and ends by category
by_category = {}
for date, date_facts in groupby(facts, lambda fact: fact["start_time"].date()):
date_facts = sorted(list(date_facts), key = lambda x: x["category"])
for category, category_facts in groupby(date_facts, lambda x: x["category"]):
category_facts = list(category_facts)
by_category.setdefault(category, [])
start_times, end_times = [], []
for fact in category_facts:
start_time = fact["start_time"]
start_time = start_time.hour * 60 + start_time.minute
if fact["end_time"]:
end_time = fact["end_time"].time()
end_time = end_time.hour * 60 + end_time.minute
if start_time < split_minutes:
start_time += 24 * 60
if end_time < start_time:
end_time += 24 * 60
start_times.append(start_time)
end_times.append(end_time)
if start_times and end_times:
by_category[category].append((min(start_times), max(end_times)))
for cat in by_category:
by_category[cat] = (sum([fact[0] for fact in by_category[cat]]) / len(by_category[cat]),
sum([fact[1] for fact in by_category[cat]]) / len(by_category[cat]))
min_category = min([by_category[day][0] for day in by_category])
max_category = max([by_category[day][1] for day in by_category])
category_keys = sorted(by_category.keys(), key = lambda x: x[0])
categories = [by_category[key] for key in category_keys]
#get starting and ending hours for graph and turn them into exact hours that divide by 3
min_hour = min([min_weekday, min_category]) / 60 * 60
max_hour = max([max_weekday, max_category]) / 60 * 60
self.chart_weekday_starts_ends.plot_day(weekday_keys, weekdays, min_hour, max_hour)
self.chart_category_starts_ends.plot_day(category_keys, categories, min_hour, max_hour)
#now the factoids!
summary = ""
# first record
if not year:
# date format for the first record if the year has not been selected
# Using python datetime formatting syntax. See:
# http://docs.python.org/library/time.html#time.strftime
first_date = facts[0]["start_time"].strftime(C_("first record", "%b %d, %Y"))
else:
# date of first record when year has been selected
# Using python datetime formatting syntax. See:
# http://docs.python.org/library/time.html#time.strftime
first_date = facts[0]["start_time"].strftime(C_("first record", "%b %d"))
summary += _("First activity was recorded on %s.") % \
("<b>%s</b>" % first_date)
# total time tracked
total_delta = dt.timedelta(days=0)
for fact in facts:
total_delta += fact["delta"]
if total_delta.days > 1:
human_years_str = ngettext("%(num)s year",
"%(num)s years",
total_delta.days / 365) % {
'num': "<b>%.2f</b>" % (total_delta.days / 365.0)}
working_years_str = ngettext("%(num)s year",
"%(num)s years",
total_delta.days * 3 / 365) % {
'num': "<b>%.2f</b>" % (total_delta.days * 3 / 365.0) }
#FIXME: difficult string to properly pluralize
summary += " " + _("""Time tracked so far is %(human_days)s human days \
(%(human_years)s) or %(working_days)s working days (%(working_years)s).""") % {
"human_days": ("<b>%d</b>" % total_delta.days),
"human_years": human_years_str,
"working_days": ("<b>%d</b>" % (total_delta.days * 3)), # 8 should be pretty much an average working day
"working_years": working_years_str }
# longest fact
max_fact = None
for fact in facts:
if not max_fact or fact["delta"] > max_fact["delta"]:
max_fact = fact
longest_date = max_fact["start_time"].strftime(
# How the date of the longest activity should be displayed in statistics
# Using python datetime formatting syntax. See:
# http://docs.python.org/library/time.html#time.strftime
C_("date of the longest activity", "%b %d, %Y"))
num_hours = max_fact["delta"].seconds / 60 / 60.0 + max_fact["delta"].days * 24
hours = "<b>%.1f</b>" % (num_hours)
summary += "\n" + ngettext("Longest continuous work happened on \
%(date)s and was %(hours)s hour.",
"Longest continuous work happened on \
%(date)s and was %(hours)s hours.",
int(num_hours)) % {"date": longest_date,
"hours": hours}
# total records (in selected scope)
summary += " " + ngettext("There is %s record.",
"There are %s records.",
len(facts)) % ("<b>%d</b>" % len(facts))
early_start, early_end = dt.time(5,0), dt.time(9,0)
late_start, late_end = dt.time(20,0), dt.time(5,0)
fact_count = len(facts)
def percent(condition):
matches = [fact for fact in facts if condition(fact)]
return round(len(matches) / float(fact_count) * 100)
early_percent = percent(lambda fact: early_start < fact["start_time"].time() < early_end)
late_percent = percent(lambda fact: fact["start_time"].time() > late_start or fact["start_time"].time() < late_end)
short_percent = percent(lambda fact: fact["delta"] <= dt.timedelta(seconds = 60 * 15))
if fact_count < 100:
summary += "\n\n" + _("Hamster would like to observe you some more!")
elif early_percent >= 20:
summary += "\n\n" + _("With %s percent of all facts starting before \
9am you seem to be an early bird.") % ("<b>%d</b>" % early_percent)
elif late_percent >= 20:
summary += "\n\n" + _("With %s percent of all facts starting after \
11pm you seem to be a night owl.") % ("<b>%d</b>" % late_percent)
elif short_percent >= 20:
summary += "\n\n" + _("With %s percent of all tasks being shorter \
than 15 minutes you seem to be a busy bee.") % ("<b>%d</b>" % short_percent)
self.explore_summary.set_text(summary)
def on_year_changed(self, button):
if self.bubbling: return
for child in button.parent.get_children():
if child != button and child.get_active():
self.bubbling = True
child.set_active(False)
self.bubbling = False
self.stats(button.year)
def after_fact_update(self, event, date):
self.stat_facts = runtime.storage.get_facts(dt.date(1970, 1, 1), dt.date.today())
self.stats()
def get_widget(self, name):
""" skip one variable (huh) """
return self._gui.get_object(name)
def on_window_key_pressed(self, tree, event_key):
if (event_key.keyval == gtk.keysyms.Escape
or (event_key.keyval == gtk.keysyms.w
and event_key.state & gtk.gdk.CONTROL_MASK)):
self.close_window()
def on_stats_window_deleted(self, widget, event):
self.close_window()
def close_window(self):
runtime.dispatcher.del_handler('activity_updated', self.after_fact_update)
runtime.dispatcher.del_handler('day_updated', self.after_fact_update)
if not self.parent:
gtk.main_quit()
else:
self.window.destroy()
return False
if __name__ == "__main__":
stats_viewer = Stats()
gtk.main()
|