diff --git a/src/diana/sgfParser/property.py b/src/diana/sgfParser/property.py
--- a/src/diana/sgfParser/property.py
+++ b/src/diana/sgfParser/property.py
@@ -5,8 +5,8 @@ import logging as log
 from .propValues import choose, singleton, listOf, compose, number, real, double, color, text, empty, anything, point, move, stone
 from . import skipWhitespace, ParserError
 
-GAME_INFO=1
-UNKNOWN=99
+GAME_INFO = 1
+UNKNOWN = 99
 
 
 class DateException(Exception):
@@ -14,174 +14,184 @@ class DateException(Exception):
 
 
 class Property:
-	identRegexp=re.compile(r"[A-Z]+")
+	identRegexp = re.compile(r"[A-Z]+")
 
 	def __init__(self):
-		self.name=""
-		self.value=""
+		self.name = ""
+		self.value = ""
 
 	@staticmethod
-	def fits(s,i):
-		return i<len(s) and s[i].isupper()
+	def fits(s, i):
+		return i < len(s) and s[i].isupper()
 
 	@staticmethod
-	def create(s,start):
-		assert Property.fits(s,start)
-		res=Property()
-		i,res.name=Property.ident(s,start)
-		i=skipWhitespace(s,i)
+	def create(s, start):
+		assert Property.fits(s, start)
+		res = Property()
+		(i, res.name) = Property.ident(s, start)
+		i = skipWhitespace(s, i)
 		try:
-			i,x=Property.createValue(s,i,res.name)
-		except ParserError as e: # malformed value
+			(i, x) = Property.createValue(s, i, res.name)
+		except ParserError as e:  # a malformed value
 			log.warning(e)
-			i,x=choose(listOf(anything), singleton(anything))(s,i)
-			res.name="_"+res.name
-		res.value=x
-		if res.name=="DT":
-			res=DateProperty(x)
-		i=skipWhitespace(s,i)
-		return (i,res)
+			(i, x) = choose(listOf(anything), singleton(anything))(s, i)
+			res.name = "_"+res.name
+		res.value = x
+		if res.name == "DT":
+			res = DateProperty(x)
+		i = skipWhitespace(s, i)
+		return (i, res)
 
 	@staticmethod
-	def ident(s,start):
-		m=Property.identRegexp.match(s,start)
-		if m is None: raise ParserError("expected a property identifier matching '[A-Z]+'",s,start)
-		return (m.end(),m.group())
+	def ident(s, start):
+		m = Property.identRegexp.match(s, start)
+		if m is None:
+			raise ParserError("expected a property identifier matching '[A-Z]+'", s, start)
+		return (m.end(), m.group())
 
 	@staticmethod
-	def createValue(s,start,name):
+	def createValue(s, start, name):
 		if name in Property.patterns:
-			return Property.patterns[name](s,start)
+			return Property.patterns[name](s, start)
 		else:
-			log.info("unknown property %s at position %d",name,start)
-			return choose(listOf(anything), singleton(anything))(s,start)
+			log.info("unknown property %s at position %d", name, start)
+			return choose(listOf(anything), singleton(anything))(s, start)
 
 	@property
 	def type(self):
-		gameInfo={"AN","BR","BT","CP","DT","EV","GN","GC","ON","OT","PB","PC","PW","RE","RO","RU","SO","TM","US","WR","WT"}
-		if self.name in gameInfo: return GAME_INFO
-		else: return UNKNOWN
+		gameInfo = {"AN", "BR", "BT", "CP", "DT", "EV", "GN", "GC", "ON", "OT", "PB", "PC", "PW", "RE", "RO", "RU", "SO", "TM", "US", "WR", "WT"}
+		if self.name in gameInfo:
+			return GAME_INFO
+		else:
+			return UNKNOWN
 
 	def copy(self):
-		res=Property()
-		res.name=self.name
-		res.value=self.value if not isinstance(self.value,list) else self.value[:]
+		res = Property()
+		res.name = self.name
+		res.value = self.value if not isinstance(self.value, list) else self.value[:]
 		return res
 
 	def __str__(self):
-		name=self.name.lstrip("_")
-		val="[{0}]".format(self.value) if not isinstance(self.value,list) else "".join("[{0}]".format(x) for x in self.value)
-		return "{0}{1}".format(name,val)
+		name = self.name.lstrip("_")
+		val = "[{0}]".format(self.value) \
+			if not isinstance(self.value, list) \
+			else "".join("[{0}]".format(x) for x in self.value)
+		return "{0}{1}".format(name, val)
 
-	patterns={
-		"B":singleton(move),
-		"KO":singleton(empty),
-		"MN":singleton(number),
-		"W":singleton(move),
-		"AB":listOf(stone), #
-		"AE":listOf(point), #
-		"AW":listOf(stone), #
-		"PL":singleton(color),
-		"C":singleton(text(simple=False)),
-		"DM":singleton(double),
-		"GB":singleton(double),
-		"GW":singleton(double),
-		"HO":singleton(double),
-		"N":singleton(text()),
-		"UC":singleton(double),
-		"V":singleton(real),
-		"BM":singleton(double),
-		"DO":singleton(empty),
-		"IT":singleton(empty),
-		"TE":singleton(double),
-		"AR":listOf(compose(point,point)), #
-		"CR":listOf(point), #
-		"DD":listOf(point,allowEmpty=True), #
-		"LB":listOf(compose(point,text())), #
-		"LN":listOf(compose(point,point)), #
-		"MA":listOf(point), #
-		"SL":listOf(point), #
-		"SQ":listOf(point), #
-		"TR":listOf(point), #
-		"AP":singleton(compose(text(composed=True),text())), #
-		"CA":singleton(text()),
-		"FF":singleton(number),
-		"GM":singleton(number),
-		"ST":singleton(number),
-		"SZ":choose(singleton(number),singleton(compose(number,number))), #
-		"AN":singleton(text()),
-		"BR":singleton(text()),
-		"BT":singleton(text()),
-		"CP":singleton(text()),
-		"DT":singleton(text()),
-		"EV":singleton(text()),
-		"GN":singleton(text()),
-		"GC":singleton(text(simple=False)),
-		"ON":singleton(text()),
-		"OT":singleton(text()),
-		"PB":singleton(text()),
-		"PC":singleton(text()),
-		"PW":singleton(text()),
-		"RE":singleton(text()),
-		"RO":singleton(text()),
-		"RU":singleton(text()),
-		"SO":singleton(text()),
-		"TM":singleton(real),
-		"US":singleton(text()),
-		"WR":singleton(text()),
-		"WT":singleton(text()),
-		"BL":singleton(real),
-		"OB":singleton(number),
-		"OW":singleton(number),
-		"WL":singleton(real),
-		"FG":choose(singleton(empty),singleton(compose(number,text()))), #
-		"PM":singleton(number),
-		"VW":listOf(point,allowEmpty=True), #
+	patterns = {
+		"B": singleton(move),
+		"KO": singleton(empty),
+		"MN": singleton(number),
+		"W": singleton(move),
+		"AB": listOf(stone),  #
+		"AE": listOf(point),  #
+		"AW": listOf(stone),  #
+		"PL": singleton(color),
+		"C": singleton(text(simple=False)),
+		"DM": singleton(double),
+		"GB": singleton(double),
+		"GW": singleton(double),
+		"HO": singleton(double),
+		"N": singleton(text()),
+		"UC": singleton(double),
+		"V": singleton(real),
+		"BM": singleton(double),
+		"DO": singleton(empty),
+		"IT": singleton(empty),
+		"TE": singleton(double),
+		"AR": listOf(compose(point, point)),  #
+		"CR": listOf(point),  #
+		"DD": listOf(point, allowEmpty=True),  #
+		"LB": listOf(compose(point, text())),  #
+		"LN": listOf(compose(point, point)),  #
+		"MA": listOf(point),  #
+		"SL": listOf(point),  #
+		"SQ": listOf(point),  #
+		"TR": listOf(point),  #
+		"AP": singleton(compose(text(composed=True), text())),  #
+		"CA": singleton(text()),
+		"FF": singleton(number),
+		"GM": singleton(number),
+		"ST": singleton(number),
+		"SZ": choose(singleton(number), singleton(compose(number, number))),  #
+		"AN": singleton(text()),
+		"BR": singleton(text()),
+		"BT": singleton(text()),
+		"CP": singleton(text()),
+		"DT": singleton(text()),
+		"EV": singleton(text()),
+		"GN": singleton(text()),
+		"GC": singleton(text(simple=False)),
+		"ON": singleton(text()),
+		"OT": singleton(text()),
+		"PB": singleton(text()),
+		"PC": singleton(text()),
+		"PW": singleton(text()),
+		"RE": singleton(text()),
+		"RO": singleton(text()),
+		"RU": singleton(text()),
+		"SO": singleton(text()),
+		"TM": singleton(real),
+		"US": singleton(text()),
+		"WR": singleton(text()),
+		"WT": singleton(text()),
+		"BL": singleton(real),
+		"OB": singleton(number),
+		"OW": singleton(number),
+		"WL": singleton(real),
+		"FG": choose(singleton(empty), singleton(compose(number, text()))),  #
+		"PM": singleton(number),
+		"VW": listOf(point, allowEmpty=True),  #
 
 		# go specific
-		"HA":singleton(number),
-		"KM":singleton(real),
-		"TB":listOf(point,allowEmpty=True),
-		"TW":listOf(point,allowEmpty=True)
+		"HA": singleton(number),
+		"KM": singleton(real),
+		"TB": listOf(point, allowEmpty=True),
+		"TW": listOf(point, allowEmpty=True)
 	}
 
 
 class DateProperty(Property):
-	def __init__(self,value):
+	def __init__(self, value):
 		super().__init__()
-		self.name="DT"
-		self.value=[]
-		self.rawValue=value
+		self.name = "DT"
+		self.value = []
+		self.rawValue = value
 		self.parse(value)
 
-	def parse(self,s):
-		regexp=re.compile(r"\d{4}(-\d\d){0,2}(,(\d{4}(-\d\d){0,2}|\d\d(-\d\d)?))*")
-		match=re.search(regexp,s)
+	def parse(self, s):
+		regexp = re.compile(r"\d{4}(-\d\d){0,2}(,(\d{4}(-\d\d){0,2}|\d\d(-\d\d)?))*")
+		match = re.search(regexp, s)
 		if not match:
 			raise DateException('Could not parse a DT value: "{0}"'.format(s))
-		substr=match.group(0)
-		dateStrs=substr.split(",")
-		dates=[]
-		prevFormat=None
+		substr = match.group(0)
+		dateStrs = substr.split(",")
+		dates = []
+		prevFormat = None
 
 		for s in dateStrs:
 			try:
-				(prevFormat,d)=DateProperty.parseSingle(s,prevFormat,dates[-1] if dates else None)
+				(prevFormat, d) = DateProperty.parseSingle(s, prevFormat, dates[-1] if dates else None)
 			except ValueError:
 				raise DateException('Could not parse a DT value: "{0}"'.format(s))
 			dates.append(d)
-		self.value=dates
+		self.value = dates
 
 	@staticmethod
-	def parseSingle(dateStr,prevFormat,prev=None):
-		tokens=dateStr.split("-")
-		num_tokens=list(map(int,tokens))
-		if len(tokens)==3:
-			return ("YMD",date(*num_tokens))
-		elif len(tokens)==2:
-			if len(tokens[0])==4: return ("YM",date(*num_tokens,1))
-			else: return ("MD",date(prev.year,*num_tokens))
+	def parseSingle(dateStr, prevFormat, prev=None):
+		tokens = dateStr.split("-")
+		num_tokens = list(map(int, tokens))
+		if len(tokens) == 3:
+			return ("YMD", date(*num_tokens))
+		elif len(tokens) == 2:
+			if len(tokens[0]) == 4:
+				return ("YM", date(*num_tokens, 1))
+			else:
+				return ("MD", date(prev.year, *num_tokens))
 		else:
-			if len(tokens[0])==4: return ("Y",date(*num_tokens,1,1))
-			elif prevFormat in ("YM","M"): return ("M",date(prev.year,*num_tokens,1))
-			else: return ("D",date(prev.year,prev.month,*num_tokens))
+			if len(tokens[0]) == 4:
+				return ("Y", date(*num_tokens, 1, 1))
+			elif prevFormat in ("YM","M"):
+				return ("M", date(prev.year, *num_tokens, 1))
+			else:
+				return ("D", date(prev.year, prev.month, *num_tokens))