diff --git a/src/diana/diana.py b/src/diana/diana.py
--- a/src/diana/diana.py
+++ b/src/diana/diana.py
@@ -3,18 +3,18 @@ import re
 
 from . import config as cfg
 from . import go
-from .go import BLACK,WHITE,EMPTY
+from .go import BLACK, WHITE, EMPTY
 from .sgfParser import ParserError
 from .sgfParser.collection import Collection
 from .drawer.svg import Svg
 from .drawer.tikz import Tikz
 
 
-def collectMoves(root):
+def collect_moves(root):
 	node = root
 	while len(node.children) > 0:
-		b = node.getProp("B")
-		w = node.getProp("W")
+		b = node.get_prop("B")
+		w = node.get_prop("W")
 		if b is not None:
 			yield ("b", b)
 		elif w is not None:
@@ -25,46 +25,46 @@ def collectMoves(root):
 
 
 class SourceFile:
-	def __init__(self, fileName):
-		self.fileName = fileName
-		self._shortName = "".join(re.split(r'[/\\]', fileName)[-1].split('.')[:-1])
+	def __init__(self, file_name):
+		self.file_name = file_name
+		self._short_name = "".join(re.split(r'[/\\]', file_name)[-1].split('.')[:-1])
 		self._game = go.Go()
 
-		with open(self.fileName, 'r', encoding=cfg.encoding) as f:
-			games = Collection(f.read()).listGames()
+		with open(self.file_name, 'r', encoding=cfg.encoding) as f:
+			games = Collection(f.read()).list_games()
 		self._record = list(games)[0]
-		self._moves = list(collectMoves(self._record.root))
+		self._moves = list(collect_moves(self._record.root))
 
 	def process(self):
-		print("{0}... ".format(self.fileName), end="")
+		print("{0}... ".format(self.file_name), end="")
 
 		i = 1
-		for k in range(0,len(self._moves), cfg.movesPerDiagram):
-			filename = os.path.join(cfg.outputDir, "{0}-{1}".format(self._shortName, i))
-			self.createDiagram(k, k+cfg.movesPerDiagram).save(filename, "templ-pleb.svg")
+		for k in range(0, len(self._moves), cfg.moves_per_diagram):
+			filename = os.path.join(cfg.output_dir, "{0}-{1}".format(self._short_name, i))
+			self.create_diagram(k, k + cfg.moves_per_diagram).save(filename, "templ-pleb.svg")
 			i += 1
 
-		infoStr = """{GN}
+		info_str = """{GN}
 B: {PB} {BR}
 W: {PW} {WR}
 {DT}
-{RE}""".format(**self.fetchGameInfo(["GN","PB","BR","PW","WR","DT","RE"], ""))
-		notes = open(os.path.join(cfg.outputDir, "{0}.txt".format(self._shortName)), 'w')
-		notes.write(infoStr)
+{RE}""".format(**self.fetch_game_info(["GN", "PB", "BR", "PW", "WR", "DT", "RE"], ""))
+		notes = open(os.path.join(cfg.output_dir, "{0}.txt".format(self._short_name)), 'w')
+		notes.write(info_str)
 		notes.close()
 		print("done")
 
-	def createDiagram(self, start, end):
+	def create_diagram(self, start, end):
 		# initialize the diagram
 		template = Svg()
 
-		self._setMove(start)
+		self._set_move(start)
 
 		# draw current state
-		for lineNumber, line in enumerate(self._game.board):
-			for itemNumber, item in enumerate(line):
+		for (line_number, line) in enumerate(self._game.board):
+			for (item_number, item) in enumerate(line):
 				if item != EMPTY:
-					template.addStone(itemNumber, lineNumber, "b" if item==BLACK else "w")
+					template.add_stone(item_number, line_number, "b" if item == BLACK else "w")
 
 		# draw the moves
 		for k in range(start, end):
@@ -73,35 +73,35 @@ W: {PW} {WR}
 
 			color, move = self._moves[k]
 			if move == tuple():
-				template.overlays.append((k, "pass")) # !!
+				template.overlays.append((k, "pass"))  # !!
 				continue
 			else:
 				(c, r) = move
 
 			if not self._move(color, c, r):
-				if cfg.keepBroken:
+				if cfg.keep_broken:
 					continue
 				else:
 					return False
 
 			# draw the move
-			template.addMove(c, r, color, k+1)
+			template.add_move(c, r, color, k + 1)
 
 		return template
 
-	def fetchGameInfo(self, fieldNames, default=None):
-		return {k: self._record.get(k, default) for k in fieldNames}
+	def fetch_game_info(self, field_names, default=None):
+		return {k: self._record.get(k, default) for k in field_names}
 
-	def _setMove(self, k):
+	def _set_move(self, k):
 		self._game = go.Go()
 
-		blackStones = self._record.root.getProp("AB")
-		whiteStones = self._record.root.getProp("AW")
-		if blackStones:
-			for p in blackStones:
+		black_stones = self._record.root.get_prop("AB")
+		white_stones = self._record.root.get_prop("AW")
+		if black_stones:
+			for p in black_stones:
 				self._game.board[p.r][p.c] = BLACK
-		if whiteStones:
-			for p in whiteStones:
+		if white_stones:
+			for p in white_stones:
 				self._game.board[p.r][p.c] = WHITE
 
 		for i in range(k):
@@ -113,8 +113,8 @@ W: {PW} {WR}
 	def _move(self, color, c, r):
 		if not self._game.move(BLACK if color=='b' else WHITE, c, r):
 			# !! we do not honor http://red-bean.com/sgf/ff5/m_vs_ax.htm at the moment
-			msg = "illegal move: {0} at {1},{2}".format(self._game.moveCount+1, c, r)
-			if cfg.keepBroken:
+			msg = "illegal move: {0} at {1},{2}".format(self._game.move_count + 1, c, r)
+			if cfg.keep_broken:
 				print(msg)
 			else:
 				msg += ". aborted"
@@ -124,9 +124,9 @@ W: {PW} {WR}
 
 
 def main():
-	cfg.parseArgs()
+	cfg.parse_args()
 	print("processing:")
-	files = cfg.inputFiles[:]
+	files = cfg.input_files[:]
 
 	for item in files:
 		if os.path.isfile(item):