Merge pull request #1 from christhoval06/chore/python3

Chore/python3

.gitignore

+
+.DS_Store

README.md

+# Gitstats - meaningful data for your git repository. 
+
+## How to run
+1. Clone this repo and `cd` into it
+2. Create a output directory for your output
+3. `./gitstats [path_to_git_repo] [path_to_output_folder]`
+4. Open the `index.html` within your `ouptut_folder`
+
+## Dependencies
+
+* Gnuplot
+  * MacOS: `brew install gnuplot`
+  * Ubuntu: `sudo apt-get install gnuplot`
+* Git
+* Python >= 3.0

gitstats

-#!/usr/bin/env python2
+#!/usr/bin/env python3
 # Copyright (c) 2007-2014 Heikki Hokkanen <hoxu@users.sf.net> & others (see doc/AUTHOR)
 # GPLv2 / GPLv3
 import datetime
 import getopt
 import glob
+import json
 import os
 import pickle
 import platform
 import sys
 import time
 import zlib
+import multiprocessing
 
 if sys.version_info < (2, 6):
 	print >> sys.stderr, "Python 2.6 or higher is required for gitstats"
 GNUPLOT_COMMON = 'set terminal png transparent size 640,240\nset size 1.0,1.0\n'
 ON_LINUX = (platform.system() == 'Linux')
 WEEKDAYS = ('Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun')
+JSONFILE = 'gitstats.json'
 
 exectime_internal = 0.0
 exectime_external = 0.0
 	'commit_end': 'HEAD',
 	'linear_linestats': 1,
 	'project_name': '',
-	'processes': 8,
-	'start_date': ''
+	'processes': multiprocessing.cpu_count(),
+	'start_date': '',
+	'end_date': '',
+	'excluded_authors': [],
+	'excluded_prefixes': []
 }
 
 def getpipeoutput(cmds, quiet = False):
 	global exectime_external
 	start = time.time()
 	if not quiet and ON_LINUX and os.isatty(1):
-		print '>> ' + ' | '.join(cmds),
+		print('>> ' + ' | '.join(cmds))
 		sys.stdout.flush()
 	p = subprocess.Popen(cmds[0], stdout = subprocess.PIPE, shell = True)
 	processes=[p]
 	for x in cmds[1:]:
 		p = subprocess.Popen(x, stdin = p.stdout, stdout = subprocess.PIPE, shell = True)
 		processes.append(p)
-	output = p.communicate()[0]
+	output = (p.communicate()[0]).decode("utf-8")
 	for p in processes:
 		p.wait()
 	end = time.time()
 	if not quiet:
 		if ON_LINUX and os.isatty(1):
-			print '\r',
-		print '[%.5f] >> %s' % (end - start, ' | '.join(cmds))
+			print('\r')
+		print('[%.5f] >> %s' % (end - start, ' | '.join(cmds)))
 	exectime_external += (end - start)
 	return output.rstrip('\n')
 
 def getlogrange(defaultrange = 'HEAD', end_only = True):
 	commit_range = getcommitrange(defaultrange, end_only)
+	datesel = ''
 	if len(conf['start_date']) > 0:
-		return '--since="%s" "%s"' % (conf['start_date'], commit_range)
+		datesel = '--since="%s" %s' % (conf['start_date'], datesel)
+	if len(conf['end_date']) > 0:
+		datesel = '--until="%s" %s' % (conf['end_date'], datesel)
+    
+	if (len(datesel) > 0):
+		commit_range = '%s "%s"' % (datesel, commit_range)
+
 	return commit_range
 
 def getcommitrange(defaultrange = 'HEAD', end_only = False):
 	return defaultrange
 
 def getkeyssortedbyvalues(dict):
-	return map(lambda el : el[1], sorted(map(lambda el : (el[1], el[0]), dict.items())))
+	return list(map(lambda el : el[1], sorted(map(lambda el : (el[1], el[0]), dict.items()))))
 
 # dict['author'] = { 'commits': 512 } - ...key(dict, 'commits')
 def getkeyssortedbyvaluekey(d, key):
-	return map(lambda el : el[1], sorted(map(lambda el : (d[el][key], el), d.keys())))
+	return list(map(lambda el : el[1], sorted(map(lambda el : (d[el][key], el), d.keys()))))
 
 def getstatsummarycounts(line):
 	numbers = re.findall('\d+', line)
 		self.activity_by_hour_of_week_busiest = 0
 		self.activity_by_year_week = {} # yy_wNN -> commits
 		self.activity_by_year_week_peak = 0
+		self.lineactivity_by_hour_of_day = {} # hour -> commits
+		self.lineactivity_by_day_of_week = {} # day -> commits
+		self.lineactivity_by_month_of_year = {} # month [1-12] -> commits
+		self.lineactivity_by_hour_of_week = {} # weekday -> hour -> commits
+		self.lineactivity_by_hour_of_day_busiest = 0
+		self.lineactivity_by_hour_of_week_busiest = 0
+		self.lineactivity_by_year_week = {} # yy_wNN -> commits
+		self.lineactivity_by_year_week_peak = 0
 
 		self.authors = {} # name -> {commits, first_commit_stamp, last_commit_stamp, last_active_day, active_days, lines_added, lines_removed}
 
 	def loadCache(self, cachefile):
 		if not os.path.exists(cachefile):
 			return
-		print 'Loading cache...'
+		print('Loading cache...')
 		f = open(cachefile, 'rb')
 		try:
 			self.cache = pickle.loads(zlib.decompress(f.read()))
 
 	def getActivityByHourOfDay(self):
 		return {}
+	
+	def getLineActivityByDayOfWeek(self):
+		return {}
+
+	def getLineActivityByHourOfDay(self):
+		return {}
 
 	# : get a dictionary of domains
 	def getDomainInfo(self, domain):
 	def getTotalFiles(self):
 		return -1
 	
+	def getTotalLines(self):
+		return -1
+	
 	def getTotalLOC(self):
 		return -1
 	
 	##
 	# Save cacheable data
 	def saveCache(self, cachefile):
-		print 'Saving cache...'
+		print('Saving cache...')
 		tempfile = cachefile + '.tmp'
 		f = open(tempfile, 'wb')
 		#pickle.dump(self.cache, f)
 				self.tags[tag] = { 'stamp': stamp, 'hash' : hash, 'date' : datetime.datetime.fromtimestamp(stamp).strftime('%Y-%m-%d'), 'commits': 0, 'authors': {} }
 
 		# collect info on tags, starting from latest
-		tags_sorted_by_date_desc = map(lambda el : el[1], reversed(sorted(map(lambda el : (el[1]['date'], el[0]), self.tags.items()))))
+		tags_sorted_by_date_desc = list(map(lambda el : el[1], reversed(sorted(map(lambda el : (el[1]['date'], el[0]), self.tags.items())))))
 		prev = None
 		for tag in reversed(tags_sorted_by_date_desc):
 			cmd = 'git shortlog -s "%s"' % tag
 				parts = re.split('\s+', line, 2)
 				commits = int(parts[1])
 				author = parts[2]
+				if author in conf["excluded_authors"]:
+					continue
 				self.tags[tag]['commits'] += commits
 				self.tags[tag]['authors'][author] = commits
 
 			timezone = parts[3]
 			author, mail = parts[4].split('<', 1)
 			author = author.rstrip()
+			if author in conf["excluded_authors"]:
+				continue
 			mail = mail.rstrip('>')
 			domain = '?'
 			if mail.find('@') != -1:
 			self.commits_by_timezone[timezone] = self.commits_by_timezone.get(timezone, 0) + 1
 
 		# outputs "<stamp> <files>" for each revision
-		revlines = getpipeoutput(['git rev-list --pretty=format:"%%at %%T" %s' % getlogrange('HEAD'), 'grep -v ^commit']).strip().split('\n')
+		revlines = getpipeoutput(['git rev-list --pretty=format:"%%at %%T %%an" %s' % getlogrange('HEAD'), 'grep -v ^commit']).strip().split('\n')
 		lines = []
 		revs_to_read = []
 		time_rev_count = []
 		#Look up rev in cache and take info from cache if found
 		#If not append rev to list of rev to read from repo
 		for revline in revlines:
-			time, rev = revline.split(' ')
+			_revline = revline.split(' ')
+			time, rev = _revline[:2]
+			author = ' '.join(_revline[2:])
+			if author in conf["excluded_authors"]:
+				continue
 			#if cache empty then add time and rev to list of new rev's
 			#otherwise try to read needed info from cache
 			if 'files_in_tree' not in self.cache.keys():
 			try:
 				self.files_by_stamp[int(stamp)] = int(files)
 			except ValueError:
-				print 'Warning: failed to parse line "%s"' % line
+				print('Warning: failed to parse line "%s"' % line)
 
 		# extensions and size of files
 		lines = getpipeoutput(['git ls-tree -r -l -z %s' % getcommitrange('HEAD', end_only = True)]).split('\000')
 			blob_id = parts[2]
 			size = int(parts[3])
 			fullpath = parts[4]
+			exclude = False
+			for path in conf["excluded_prefixes"]:
+				if fullpath.startswith(path):
+					exclude = True
+					break
+
+			if exclude:
+				continue
 
 			self.total_size += size
 			self.total_files += 1
 		lines.reverse()
 		files = 0; inserted = 0; deleted = 0; total_lines = 0
 		author = None
+		last_line = ""
 		for line in lines:
 			if len(line) == 0:
 				continue
 				if pos != -1:
 					try:
 						(stamp, author) = (int(line[:pos]), line[pos+1:])
-						self.changes_by_date[stamp] = { 'files': files, 'ins': inserted, 'del': deleted, 'lines': total_lines }
-
-						date = datetime.datetime.fromtimestamp(stamp)
-						yymm = date.strftime('%Y-%m')
-						self.lines_added_by_month[yymm] = self.lines_added_by_month.get(yymm, 0) + inserted
-						self.lines_removed_by_month[yymm] = self.lines_removed_by_month.get(yymm, 0) + deleted
-
-						yy = date.year
-						self.lines_added_by_year[yy] = self.lines_added_by_year.get(yy,0) + inserted
-						self.lines_removed_by_year[yy] = self.lines_removed_by_year.get(yy, 0) + deleted
-
-						files, inserted, deleted = 0, 0, 0
+						if author not in conf["excluded_authors"]:
+							self.changes_by_date[stamp] = { 'files': files, 'ins': inserted, 'del': deleted, 'lines': total_lines }
+
+							date = datetime.datetime.fromtimestamp(stamp)
+							yymm = date.strftime('%Y-%m')
+							self.lines_added_by_month[yymm] = self.lines_added_by_month.get(yymm, 0) + inserted
+							self.lines_removed_by_month[yymm] = self.lines_removed_by_month.get(yymm, 0) + deleted
+
+							yy = date.year
+							self.lines_added_by_year[yy] = self.lines_added_by_year.get(yy,0) + inserted
+							self.lines_removed_by_year[yy] = self.lines_removed_by_year.get(yy, 0) + deleted
+
+							# lineactivity
+							# hour
+							hour = date.hour
+							self.lineactivity_by_hour_of_day[hour] = self.lineactivity_by_hour_of_day.get(hour, 0) + inserted + deleted
+							# most active hour?
+							if self.lineactivity_by_hour_of_day[hour] > self.lineactivity_by_hour_of_day_busiest:
+								self.lineactivity_by_hour_of_day_busiest = self.lineactivity_by_hour_of_day[hour]
+
+							# day of week
+							day = date.weekday()
+							self.lineactivity_by_day_of_week[day] = self.lineactivity_by_day_of_week.get(day, 0) + inserted + deleted
+
+							# domain stats
+							#if domain not in self.domains:
+								#self.domains[domain] = {}
+							# lines
+							#self.domains[domain]['lines'] = self.domains[domain].get('lines', 0) + 1
+
+							# hour of week
+							if day not in self.lineactivity_by_hour_of_week:
+								self.lineactivity_by_hour_of_week[day] = {}
+							self.lineactivity_by_hour_of_week[day][hour] = self.lineactivity_by_hour_of_week[day].get(hour, 0) + inserted + deleted
+							# most active hour?
+							if self.lineactivity_by_hour_of_week[day][hour] > self.lineactivity_by_hour_of_week_busiest:
+								self.lineactivity_by_hour_of_week_busiest = self.lineactivity_by_hour_of_week[day][hour]
+
+							# month of year
+							month = date.month
+							self.lineactivity_by_month_of_year[month] = self.lineactivity_by_month_of_year.get(month, 0) + inserted + deleted
+
+							# yearly/weekly activity
+							yyw = date.strftime('%Y-%W')
+							self.lineactivity_by_year_week[yyw] = self.lineactivity_by_year_week.get(yyw, 0) + inserted + deleted
+							if self.lineactivity_by_year_week_peak < self.lineactivity_by_year_week[yyw]:
+								self.lineactivity_by_year_week_peak = self.lineactivity_by_year_week[yyw]
+
+							files, inserted, deleted = 0, 0, 0
+
+							numbers = getstatsummarycounts(last_line)
+							if len(numbers) == 3:
+								(files, inserted, deleted) = map(lambda el : int(el), numbers)
+								total_lines += inserted
+								total_lines -= deleted
+								self.total_lines_added += inserted
+								self.total_lines_removed += deleted
+							else:
+								print('Warning: failed to handle line "%s"' % line)
+								(files, inserted, deleted) = (0, 0, 0)
 					except ValueError:
-						print 'Warning: unexpected line "%s"' % line
+						print('Warning: unexpected line "%s"' % line)
 				else:
-					print 'Warning: unexpected line "%s"' % line
+					print('Warning: unexpected line "%s"' % line)
 			else:
-				numbers = getstatsummarycounts(line)
-
-				if len(numbers) == 3:
-					(files, inserted, deleted) = map(lambda el : int(el), numbers)
-					total_lines += inserted
-					total_lines -= deleted
-					self.total_lines_added += inserted
-					self.total_lines_removed += deleted
-
-				else:
-					print 'Warning: failed to handle line "%s"' % line
-					(files, inserted, deleted) = (0, 0, 0)
+				last_line = line
 				#self.changes_by_date[stamp] = { 'files': files, 'ins': inserted, 'del': deleted }
 		self.total_lines += total_lines
 
 					try:
 						oldstamp = stamp
 						(stamp, author) = (int(line[:pos]), line[pos+1:])
-						if oldstamp > stamp:
-							# clock skew, keep old timestamp to avoid having ugly graph
-							stamp = oldstamp
-						if author not in self.authors:
-							self.authors[author] = { 'lines_added' : 0, 'lines_removed' : 0, 'commits' : 0}
-						self.authors[author]['commits'] = self.authors[author].get('commits', 0) + 1
-						self.authors[author]['lines_added'] = self.authors[author].get('lines_added', 0) + inserted
-						self.authors[author]['lines_removed'] = self.authors[author].get('lines_removed', 0) + deleted
-						if stamp not in self.changes_by_date_by_author:
-							self.changes_by_date_by_author[stamp] = {}
-						if author not in self.changes_by_date_by_author[stamp]:
-							self.changes_by_date_by_author[stamp][author] = {}
-						self.changes_by_date_by_author[stamp][author]['lines_added'] = self.authors[author]['lines_added']
-						self.changes_by_date_by_author[stamp][author]['commits'] = self.authors[author]['commits']
-						files, inserted, deleted = 0, 0, 0
+						if author not in conf["excluded_authors"]:
+							if oldstamp > stamp:
+								# clock skew, keep old timestamp to avoid having ugly graph
+								stamp = oldstamp
+							if author not in self.authors:
+								self.authors[author] = { 'lines_added' : 0, 'lines_removed' : 0, 'commits' : 0}
+							self.authors[author]['commits'] = self.authors[author].get('commits', 0) + 1
+							self.authors[author]['lines_added'] = self.authors[author].get('lines_added', 0) + inserted
+							self.authors[author]['lines_removed'] = self.authors[author].get('lines_removed', 0) + deleted
+							if stamp not in self.changes_by_date_by_author:
+								self.changes_by_date_by_author[stamp] = {}
+							if author not in self.changes_by_date_by_author[stamp]:
+								self.changes_by_date_by_author[stamp][author] = {}
+							self.changes_by_date_by_author[stamp][author]['lines_added'] = self.authors[author]['lines_added']
+							self.changes_by_date_by_author[stamp][author]['commits'] = self.authors[author]['commits']
+							files, inserted, deleted = 0, 0, 0
 					except ValueError:
-						print 'Warning: unexpected line "%s"' % line
+						print('Warning: unexpected line "%s"' % line)
 				else:
-					print 'Warning: unexpected line "%s"' % line
+					print('Warning: unexpected line "%s"' % line)
 			else:
 				numbers = getstatsummarycounts(line);
 
 				if len(numbers) == 3:
-					(files, inserted, deleted) = map(lambda el : int(el), numbers)
+					(files, inserted, deleted) = list(map(lambda el : int(el), numbers))
 				else:
-					print 'Warning: failed to handle line "%s"' % line
+					print('Warning: failed to handle line "%s"' % line)
 					(files, inserted, deleted) = (0, 0, 0)
 	
 	def refine(self):
 
 	def getActivityByHourOfDay(self):
 		return self.activity_by_hour_of_day
+	
+	def getLineActivityByDayOfWeek(self):
+		return self.lineactivity_by_day_of_week
+
+	def getLineActivityByHourOfDay(self):
+		return self.lineactivity_by_hour_of_day
 
 	def getAuthorInfo(self, author):
 		return self.authors[author]
 	
 	def getTotalLOC(self):
 		return self.total_lines
+	
+	def getTotalLines(self):
+		return self.total_lines_added + self.total_lines_removed
 
 	def getTotalSize(self):
 		return self.total_size
 	name = html_linkify(text)
 	return '\n<h%d id="%s"><a href="#%s">%s</a></h%d>\n\n' % (level, name, name, text, level)
 
+
+class GitDataCollectorJSONEncoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, set):
+            return list(obj)
+        if isinstance(obj, datetime.timedelta):
+            return str(obj)
+        if isinstance(obj, GitDataCollector):
+            return obj.__dict__
+        # Let the base class default method raise the TypeError
+        return json.JSONEncoder.default(self, obj)
+
+class JSONReportCreator(ReportCreator):
+    def create(self, data, filename):
+        f = open(filename, 'w')
+        json.dump(data, f, indent=True,
+                cls=GitDataCollectorJSONEncoder)
+        f.close()
 class HTMLReportCreator(ReportCreator):
 	def create(self, data, path):
 		ReportCreator.create(self, data, path)
 					shutil.copyfile(src, path + '/' + file)
 					break
 			else:
-				print 'Warning: "%s" not found, so not copied (searched: %s)' % (file, basedirs)
+				print('Warning: "%s" not found, so not copied (searched: %s)' % (file, basedirs))
 
 		f = open(path + "/index.html", 'w')
 		format = '%Y-%m-%d %H:%M:%S'
 
 		self.printNav(f)
 
-		f.write('<dl>')
+		f.write('<div><div class="card-body"><dl>')
 		f.write('<dt>Project name</dt><dd>%s</dd>' % (data.projectname))
 		f.write('<dt>Generated</dt><dd>%s (in %d seconds)</dd>' % (datetime.datetime.now().strftime(format), time.time() - data.getStampCreated()))
 		f.write('<dt>Generator</dt><dd><a href="http://gitstats.sourceforge.net/">GitStats</a> (version %s), %s, %s</dd>' % (getversion(), getgitversion(), getgnuplotversion()))
 		f.write('<dt>Total Lines of Code</dt><dd>%s (%d added, %d removed)</dd>' % (data.getTotalLOC(), data.total_lines_added, data.total_lines_removed))
 		f.write('<dt>Total Commits</dt><dd>%s (average %.1f commits per active day, %.1f per all days)</dd>' % (data.getTotalCommits(), float(data.getTotalCommits()) / len(data.getActiveDays()), float(data.getTotalCommits()) / data.getCommitDeltaDays()))
 		f.write('<dt>Authors</dt><dd>%s (average %.1f commits per author)</dd>' % (data.getTotalAuthors(), (1.0 * data.getTotalCommits()) / data.getTotalAuthors()))
-		f.write('</dl>')
+		f.write('</dl></div></div>')
 
 		f.write('</body>\n</html>')
 		f.close()
 			stampcur -= deltaweek
 
 		# top row: commits & bar
-		f.write('<table class="noborders"><tr>')
+		f.write('<div><div class="card-body"><table class="noborders"><tr>')
 		for i in range(0, WEEKS):
 			commits = 0
 			if weeks[i] in data.activity_by_year_week:
 		f.write('</tr><tr>')
 		for i in range(0, WEEKS):
 			f.write('<td>%s</td>' % (WEEKS - i))
-		f.write('</tr></table>')
+		f.write('</tr></table></div></div>')
 
 		# Hour of Day
 		f.write(html_header(2, 'Hour of Day'))
 		hour_of_day = data.getActivityByHourOfDay()
-		f.write('<table><tr><th>Hour</th>')
+		f.write('<div><div class="card-body"><table><tr><th>Hour</th>')
 		for i in range(0, 24):
 			f.write('<th>%d</th>' % i)
 		f.write('</tr>\n<tr><th>Commits</th>')
 					f.write('<td></td>')
 			f.write('</tr>')
 
-		f.write('</table>')
+		f.write('</table></div></div>')
 
 		# Month of Year
 		f.write(html_header(2, 'Month of Year'))
 
 		# Commits by timezone
 		f.write(html_header(2, 'Commits by Timezone'))
-		f.write('<table><tr>')
+		f.write('<div><div class="card-body"><table><tr>')
 		f.write('<th>Timezone</th><th>Commits</th>')
 		f.write('</tr>')
 		max_commits_on_tz = max(data.commits_by_timezone.values())
 			commits = data.commits_by_timezone[i]
 			r = 127 + int((float(commits) / max_commits_on_tz) * 128)
 			f.write('<tr><th>%s</th><td style="background-color: rgb(%d, 0, 0)">%d</td></tr>' % (i, r, commits))
-		f.write('</table>')
+		f.write('</table></div>')
 
 		f.write('</body></html>')
 		f.close()
 		# Authors :: List of authors
 		f.write(html_header(2, 'List of Authors'))
 
-		f.write('<table class="authors sortable" id="authors">')
+		f.write('<div><div class="card-body"><table class="authors sortable" id="authors">')
 		f.write('<tr><th>Author</th><th>Commits (%)</th><th>+ lines</th><th>- lines</th><th>First commit</th><th>Last commit</th><th class="unsortable">Age</th><th>Active days</th><th># by commits</th></tr>')
 		for author in data.getAuthors(conf['max_authors']):
 			info = data.getAuthorInfo(author)
 			f.write('<tr><td>%s</td><td>%d (%.2f%%)</td><td>%d</td><td>%d</td><td>%s</td><td>%s</td><td>%s</td><td>%d</td><td>%d</td></tr>' % (author, info['commits'], info['commits_frac'], info['lines_added'], info['lines_removed'], info['date_first'], info['date_last'], info['timedelta'], len(info['active_days']), info['place_by_commits']))
-		f.write('</table>')
+		f.write('</table></div></div>')
 
 		allauthors = data.getAuthors()
 		if len(allauthors) > conf['max_authors']:
 			fg.write('%d %d\n' % (stamp, data.changes_by_date[stamp]['lines']))
 		fg.close()
 
+		# Weekly activity
+		WEEKS = 32
+		f.write(html_header(2, 'Weekly activity'))
+		f.write('<p>Last %d weeks</p>' % WEEKS)
+
+		# generate weeks to show (previous N weeks from now)
+		now = datetime.datetime.now()
+		deltaweek = datetime.timedelta(7)
+		weeks = []
+		stampcur = now
+		for i in range(0, WEEKS):
+			weeks.insert(0, stampcur.strftime('%Y-%W'))
+			stampcur -= deltaweek
+
+		# top row: commits & bar
+		f.write('<table class="noborders"><tr>')
+		for i in range(0, WEEKS):
+			commits = 0
+			if weeks[i] in data.lineactivity_by_year_week:
+				commits = data.lineactivity_by_year_week[weeks[i]]
+
+			percentage = 0
+			if weeks[i] in data.lineactivity_by_year_week:
+				percentage = float(data.lineactivity_by_year_week[weeks[i]]) / data.lineactivity_by_year_week_peak
+			height = max(1, int(200 * percentage))
+			f.write('<td style="text-align: center; vertical-align: bottom">%d<div style="display: block; background-color: red; width: 20px; height: %dpx"></div></td>' % (commits, height))
+
+		# bottom row: year/week
+		f.write('</tr><tr>')
+		for i in range(0, WEEKS):
+			f.write('<td>%s</td>' % (WEEKS - i))
+		f.write('</tr></table>')
+
+		# Hour of Day
+		f.write(html_header(2, 'Hour of Day'))
+		hour_of_day = data.getLineActivityByHourOfDay()
+		f.write('<table><tr><th>Hour</th>')
+		for i in range(0, 24):
+			f.write('<th>%d</th>' % i)
+		f.write('</tr>\n<tr><th>Lines</th>')
+		fp = open(path + '/line_hour_of_day.dat', 'w')
+		for i in range(0, 24):
+			if i in hour_of_day:
+				r = 127 + int((float(hour_of_day[i]) / data.lineactivity_by_hour_of_day_busiest) * 128)
+				f.write('<td style="background-color: rgb(%d, 0, 0)">%d</td>' % (r, hour_of_day[i]))
+				fp.write('%d %d\n' % (i, hour_of_day[i]))
+			else:
+				f.write('<td>0</td>')
+				fp.write('%d 0\n' % i)
+		fp.close()
+		f.write('</tr>\n<tr><th>%</th>')
+		totallines = data.getTotalLines()
+		for i in range(0, 24):
+			if i in hour_of_day:
+				r = 127 + int((float(hour_of_day[i]) / data.lineactivity_by_hour_of_day_busiest) * 128)
+				f.write('<td style="background-color: rgb(%d, 0, 0)">%.2f</td>' % (r, (100.0 * hour_of_day[i]) / totallines))
+			else:
+				f.write('<td>0.00</td>')
+		f.write('</tr></table>')
+		f.write('<img src="line_hour_of_day.png" alt="Hour of Day" />')
+		fg = open(path + '/line_hour_of_day.dat', 'w')
+		for i in range(0, 24):
+			if i in hour_of_day:
+				fg.write('%d %d\n' % (i + 1, hour_of_day[i]))
+			else:
+				fg.write('%d 0\n' % (i + 1))
+		fg.close()
+
+		# Day of Week
+		f.write(html_header(2, 'Day of Week'))
+		day_of_week = data.getLineActivityByDayOfWeek()
+		f.write('<div class="vtable"><table>')
+		f.write('<tr><th>Day</th><th>Total (%)</th></tr>')
+		fp = open(path + '/line_day_of_week.dat', 'w')
+		for d in range(0, 7):
+			commits = 0
+			if d in day_of_week:
+				commits = day_of_week[d]
+			fp.write('%d %s %d\n' % (d + 1, WEEKDAYS[d], commits))
+			f.write('<tr>')
+			f.write('<th>%s</th>' % (WEEKDAYS[d]))
+			if d in day_of_week:
+				f.write('<td>%d (%.2f%%)</td>' % (day_of_week[d], (100.0 * day_of_week[d]) / totallines))
+			else:
+				f.write('<td>0</td>')
+			f.write('</tr>')
+		f.write('</table></div>')
+		f.write('<img src="line_day_of_week.png" alt="Day of Week" />')
+		fp.close()
+
+		# Hour of Week
+		f.write(html_header(2, 'Hour of Week'))
+		f.write('<table>')
+
+		f.write('<tr><th>Weekday</th>')
+		for hour in range(0, 24):
+			f.write('<th>%d</th>' % (hour))
+		f.write('</tr>')
+
+		for weekday in range(0, 7):
+			f.write('<tr><th>%s</th>' % (WEEKDAYS[weekday]))
+			for hour in range(0, 24):
+				try:
+					commits = data.lineactivity_by_hour_of_week[weekday][hour]
+				except KeyError:
+					commits = 0
+				if commits != 0:
+					f.write('<td')
+					r = 127 + int((float(commits) / data.lineactivity_by_hour_of_week_busiest) * 128)
+					f.write(' style="background-color: rgb(%d, 0, 0)"' % r)
+					f.write('>%d</td>' % commits)
+				else:
+					f.write('<td></td>')
+			f.write('</tr>')
+
+		f.write('</table>')
+
+		# Month of Year
+		f.write(html_header(2, 'Month of Year'))
+		f.write('<div class="vtable"><table>')
+		f.write('<tr><th>Month</th><th>Lines (%)</th></tr>')
+		fp = open (path + '/line_month_of_year.dat', 'w')
+		for mm in range(1, 13):
+			commits = 0
+			if mm in data.lineactivity_by_month_of_year:
+				commits = data.lineactivity_by_month_of_year[mm]
+			f.write('<tr><td>%d</td><td>%d (%.2f %%)</td></tr>' % (mm, commits, (100.0 * commits) / data.getTotalLines()))
+			fp.write('%d %d\n' % (mm, commits))
+		fp.close()
+		f.write('</table></div>')
+		f.write('<img src="line_month_of_year.png" alt="Month of Year" />')
+
+		# Lines by year/month
+		f.write(html_header(2, 'Lines by year/month'))
+		f.write('<div class="vtable"><table><tr><th>Month</th><th>Commits</th><th>Lines added</th><th>Lines removed</th></tr>')
+		for yymm in reversed(sorted(data.commits_by_month.keys())):
+			f.write('<tr><td>%s</td><td>%d</td><td>%d</td><td>%d</td></tr>' % (yymm, data.commits_by_month.get(yymm,0), data.lines_added_by_month.get(yymm,0), data.lines_removed_by_month.get(yymm,0)))
+		f.write('</table></div>')
+		f.write('<img src="line_commits_by_year_month.png" alt="Commits by year/month" />')
+		fg = open(path + '/line_commits_by_year_month.dat', 'w')
+		for yymm in sorted(data.commits_by_month.keys()):
+			fg.write('%s %s\n' % (yymm, data.lines_added_by_month.get(yymm, 0) + data.lines_removed_by_month.get(yymm, 0)))
+		fg.close()
+
+		# Lines by year
+		f.write(html_header(2, 'Lines by Year'))
+		f.write('<div class="vtable"><table><tr><th>Year</th><th>Commits (% of all)</th><th>Lines added</th><th>Lines removed</th></tr>')
+		for yy in reversed(sorted(data.commits_by_year.keys())):
+			f.write('<tr><td>%s</td><td>%d (%.2f%%)</td><td>%d</td><td>%d</td></tr>' % (yy, data.commits_by_year.get(yy,0), (100.0 * data.commits_by_year.get(yy,0)) / data.getTotalCommits(), data.lines_added_by_year.get(yy,0), data.lines_removed_by_year.get(yy,0)))
+		f.write('</table></div>')
+		f.write('<img src="line_commits_by_year.png" alt="Commits by Year" />')
+		fg = open(path + '/line_commits_by_year.dat', 'w')
+		for yy in sorted(data.commits_by_year.keys()):
+			fg.write('%d %d\n' % (yy, data.lines_added_by_year.get(yy,0) + data.lines_removed_by_year.get(yy,0)))
+		fg.close()
+
+		# Commits by timezone
+		f.write(html_header(2, 'Commits by Timezone'))
+		f.write('<table><tr>')
+		f.write('<th>Timezone</th><th>Commits</th>')
+		max_commits_on_tz = max(data.commits_by_timezone.values())
+		for i in sorted(data.commits_by_timezone.keys(), key = lambda n : int(n)):
+			commits = data.commits_by_timezone[i]
+			r = 127 + int((float(commits) / max_commits_on_tz) * 128)
+			f.write('<tr><th>%s</th><td style="background-color: rgb(%d, 0, 0)">%d</td></tr>' % (i, r, commits))
+		f.write('</tr></table>')
+
 		f.write('</body></html>')
 		f.close()
 
 		f.write('<table class="tags">')
 		f.write('<tr><th>Name</th><th>Date</th><th>Commits</th><th>Authors</th></tr>')
 		# sort the tags by date desc
-		tags_sorted_by_date_desc = map(lambda el : el[1], reversed(sorted(map(lambda el : (el[1]['date'], el[0]), data.tags.items()))))
+		tags_sorted_by_date_desc = list(map(lambda el : el[1], reversed(sorted(map(lambda el : (el[1]['date'], el[0]), data.tags.items())))))
 		for tag in tags_sorted_by_date_desc:
 			authorinfo = []
 			self.authors_by_commits = getkeyssortedbyvalues(data.tags[tag]['authors'])
 		self.createGraphs(path)
 	
 	def createGraphs(self, path):
-		print 'Generating graphs...'
+		print('Generating graphs...')
 
 		# hour of day
 		f = open(path + '/hour_of_day.plot', 'w')
 
 		f.close()
 
+		# hour of day
+		f = open(path + '/line_hour_of_day.plot', 'w')
+		f.write(GNUPLOT_COMMON)
+		f.write(
+"""
+set output 'line_hour_of_day.png'
+unset key
+set xrange [0.5:24.5]
+set xtics 4
+set grid y
+set ylabel "Lines"
+plot 'line_hour_of_day.dat' using 1:2:(0.5) w boxes fs solid
+""")
+		f.close()
+
+		# day of week
+		f = open(path + '/line_day_of_week.plot', 'w')
+		f.write(GNUPLOT_COMMON)
+		f.write(
+"""
+set output 'line_day_of_week.png'
+unset key
+set xrange [0.5:7.5]
+set xtics 1
+set grid y
+set ylabel "Lines"
+plot 'line_day_of_week.dat' using 1:3:(0.5):xtic(2) w boxes fs solid
+""")
+		f.close()
+
+		# Domains
+#		f = open(path + '/domains.plot', 'w')
+#		f.write(GNUPLOT_COMMON)
+#		f.write(
+#"""
+#set output 'domains.png'
+#unset key
+#unset xtics
+#set yrange [0:]
+#set grid y
+#set ylabel "Commits"
+#plot 'domains.dat' using 2:3:(0.5) with boxes fs solid, '' using 2:3:1 with labels rotate by 45 offset 0,1
+#""")
+#		f.close()
+
+		# Month of Year
+		f = open(path + '/line_month_of_year.plot', 'w')
+		f.write(GNUPLOT_COMMON)
+		f.write(
+"""
+set output 'line_month_of_year.png'
+unset key
+set xrange [0.5:12.5]
+set xtics 1
+set grid y
+set ylabel "Lines"
+plot 'line_month_of_year.dat' using 1:2:(0.5) w boxes fs solid
+""")
+		f.close()
+
+		# commits_by_year_month
+		f = open(path + '/line_commits_by_year_month.plot', 'w')
+		f.write(GNUPLOT_COMMON)
+		f.write(
+"""
+set output 'line_commits_by_year_month.png'
+unset key
+set xdata time
+set timefmt "%Y-%m"
+set format x "%Y-%m"
+set xtics rotate
+set bmargin 5
+set grid y
+set ylabel "Lines"
+plot 'line_commits_by_year_month.dat' using 1:2:(0.5) w boxes fs solid
+""")
+		f.close()
+
+		# commits_by_year
+		f = open(path + '/line_commits_by_year.plot', 'w')
+		f.write(GNUPLOT_COMMON)
+		f.write(
+"""
+set output 'line_commits_by_year.png'
+unset key
+set xtics 1 rotate
+set grid y
+set ylabel "Lines"
+set yrange [0:]
+plot 'line_commits_by_year.dat' using 1:2:(0.5) w boxes fs solid
+""")
+		f.close()
+
 		# Commits per author
 		f = open(path + '/commits_by_author.plot', 'w')
 		f.write(GNUPLOT_COMMON)
 		for f in files:
 			out = getpipeoutput([gnuplot_cmd + ' "%s"' % f])
 			if len(out) > 0:
-				print out
+				print(out)
 
 	def printHeader(self, f, title = ''):
 		f.write(
 <head>
 	<meta charset="UTF-8">
 	<title>GitStats - %s</title>
-	<link rel="stylesheet" href="%s" type="text/css">
-	<meta name="generator" content="GitStats %s">
+	<link rel="stylesheet" href="%s" type="text/css" />
+	<meta name="generator" content="GitStats %s" />
 	<script type="text/javascript" src="sortable.js"></script>
 </head>
 <body>
 """)
 		
 def usage():
-	print """
+	text = """
 Usage: gitstats [options] <gitpath..> <outputpath>
 
 Options:
 
 Please see the manual page for more details.
 """ % conf
+	print(text)
 
 
 class GitStats:
 					raise KeyError('no such key "%s" in config' % key)
 				if isinstance(conf[key], int):
 					conf[key] = int(value)
+				elif isinstance(conf[key], list):
+					conf[key].append(value)
 				else:
 					conf[key] = value
 			elif o in ('-h', '--help'):
 		except OSError:
 			pass
 		if not os.path.isdir(outputpath):
-			print 'FATAL: Output path is not a directory or does not exist'
+			print('FATAL: Output path is not a directory or does not exist')
 			sys.exit(1)
 
 		if not getgnuplotversion():
-			print 'gnuplot not found'
+			print('gnuplot not found')
 			sys.exit(1)
 
-		print 'Output path: %s' % outputpath
+		print('Output path: %s' % outputpath)
 		cachefile = os.path.join(outputpath, 'gitstats.cache')
 
 		data = GitDataCollector()
 		data.loadCache(cachefile)
 
 		for gitpath in args[0:-1]:
-			print 'Git path: %s' % gitpath
+			print('Git path: %s' % gitpath)
 
 			prevdir = os.getcwd()
 			os.chdir(gitpath)
 
-			print 'Collecting data...'
+			print('Collecting data...')
 			data.collect(gitpath)
 
 			os.chdir(prevdir)
 
-		print 'Refining data...'
+		print('Refining data...')
 		data.saveCache(cachefile)
 		data.refine()
 
 		os.chdir(rundir)
 
-		print 'Generating report...'
+		print('Generating HTML report...')
 		report = HTMLReportCreator()
 		report.create(data, outputpath)
 
+		print('Generating JSON report...')
+		report = JSONReportCreator()
+		report.create(data, os.path.join(outputpath, JSONFILE))
+
 		time_end = time.time()
 		exectime_internal = time_end - time_start
-		print 'Execution time %.5f secs, %.5f secs (%.2f %%) in external commands)' % (exectime_internal, exectime_external, (100.0 * exectime_external) / exectime_internal)
+		print('Execution time %.5f secs, %.5f secs (%.2f %%) in external commands)' % (exectime_internal, exectime_external, (100.0 * exectime_external) / exectime_internal))
 		if sys.stdin.isatty():
-			print 'You may now run:'
-			print
-			print '   sensible-browser \'%s\'' % os.path.join(outputpath, 'index.html').replace("'", "'\\''")
-			print
+			print('You may now run:')
+			print()
+			print('   sensible-browser \'%s\'' % os.path.join(outputpath, 'index.html').replace("'", "'\\''"))
+			print('   sensible-notepad \'%s\'' % os.path.join(outputpath, JSONFILE).replace("'", "'\\''"))
+			print()
 
 if __name__=='__main__':
 	g = GitStats()