Changeset - fd76ef287e30
Parent rev.
Child rev.
[Not reviewed]
default
0 5 0
Laman - 9 years ago 2016-09-18 15:57:37

sgfParser s/str/s
5 files changed with 100 insertions and 100 deletions:
src/diana/__init__.py
+chmod
src/diana/sgfParser.py
100
100
src/diana/tests/__init__.py
+chmod
src/diana/tests/data/kogos.sgf
+chmod
src/diana/tests/sgfParser.py
+chmod
0 comments (0 inline, 0 general)
src/diana/__init__.py
➞
Show inline comments
 
modified file chmod 100644 => 100755
src/diana/sgfParser.py
➞
Show inline comments
 
import re
 
 
def skipWhitespace(str,start):
 
def skipWhitespace(s,start):
 
	i=start
 
	while i<len(str) and str[i].isspace(): i+=1
 
	while i<len(s) and s[i].isspace(): i+=1
 
	return i
 
 
class Collection:
 
	def __init__(self,str):
 
	def __init__(self,s):
 
		self.gameTrees=[]
 
		i,x=GameTree.create(str,0)
 
		i,x=GameTree.create(s,0)
 
		if x is None:
 
			print("error when parsing Collection")
 
			return
 
		while x is not None:
 
			self.gameTrees.append(x)
 
			i,x=GameTree.create(str,i)
 
			i,x=GameTree.create(s,i)
 
 
class GameTree:
 
	def __init__(self):
 
		self.nodes=[]
 
		self.branches=[]
 
 
	# def __init__(self,str,start):
 
	# def __init__(self,s,start):
 
		# self.nodes=[]
 
		# self.branches=[]
 
		# if str[start]!="(":
 
		# if s[start]!="(":
 
			# print("error when parsing GameTree")
 
			# return (-1,None)
 
		# i,x=Node(str,start+1)
 
		# i,x=Node(s,start+1)
 
		# if x is None:
 
			# print("error when parsing GameTree")
 
			# return (-1,None)
 
		# while x is not None:
 
			# self.nodes.append(x)
 
			# i,x=Node(str,i)
 
		# if str[i]!=")":
 
			# i,x=Node(s,i)
 
		# if s[i]!=")":
 
			# print("error when parsing GameTree")
 
			# return (-1,None)
 
		# return (i+1,self)
 
 
	@staticmethod
 
	def create(str,start):
 
	def create(s,start):
 
		res=GameTree()
 
		i=skipWhitespace(str,start)
 
		if i>=len(str) or str[i]!="(":
 
		i=skipWhitespace(s,start)
 
		if i>=len(s) or s[i]!="(":
 
			# print("error when parsing GameTree")
 
			return (start,None)
 
		i,x=Node.create(str,start+1)
 
		i,x=Node.create(s,start+1)
 
		if x is None:
 
			# print("error when parsing GameTree")
 
			return (i,None)
 
		while x is not None:
 
			res.nodes.append(x)
 
			i=skipWhitespace(str,i)
 
			i,x=Node.create(str,i)
 
		i=skipWhitespace(str,i)
 
		i,x=GameTree.create(str,i)
 
			i=skipWhitespace(s,i)
 
			i,x=Node.create(s,i)
 
		i=skipWhitespace(s,i)
 
		i,x=GameTree.create(s,i)
 
		while x is not None:
 
			res.branches.append(x)
 
			i=skipWhitespace(str,i)
 
			i,x=GameTree.create(str,i)
 
		if str[i]!=")":
 
			i=skipWhitespace(s,i)
 
			i,x=GameTree.create(s,i)
 
		if s[i]!=")":
 
			# print("error when parsing GameTree")
 
			return (i,None)
 
		return (i+1,res)
 
 
class Node:
 
	def __init__(self):
 
		self.properties=dict()
 
 
	@staticmethod
 
	def create(str,start):
 
	def create(s,start):
 
		res=Node()
 
		if str[start]!=";":
 
		if s[start]!=";":
 
			# print("error when parsing Node")
 
			return (start,None)
 
		i=skipWhitespace(str,start+1)
 
		i,x=Property.create(str,start+1)
 
		i=skipWhitespace(s,start+1)
 
		i,x=Property.create(s,start+1)
 
		while x is not None:
 
			if x.name in res.properties:
 
				print(res.properties)
 
				raise ParserError(0,0,'duplicate "{0}" property in node at position {1}. second value ignored'.format(x.name,start))
 
			else:
 
				res.properties[x.name]=x
 
			i=skipWhitespace(str,i)
 
			i,x=Property.create(str,i)
 
			i=skipWhitespace(s,i)
 
			i,x=Property.create(s,i)
 
		return (i,res)
 
 
	def setProperty(self,name,value):
 
		self.properties[name]=value
 
		# zkontrolovat typ value
 
 
	def getProperty(self,name):
 
		if name in self.properties: return self.properties[name]
 
		else: return None
 
 
class Property:
 
	def __init__(self):
 
		self.name=""
 
		self.value=""
 
 
	@staticmethod
 
	def create(str,start):
 
	def create(s,start):
 
		res=Property()
 
		i,x=Property.ident(str,start)
 
		i,x=Property.ident(s,start)
 
		if x is None:
 
			return (start,None)
 
		res.name=x
 
		i,x=PropValue.create(str,i,res.name)
 
		i,x=PropValue.create(s,i,res.name)
 
		if x is None:
 
			print('error when parsing property "{0}" at position {1}'.format(res.name,i))
 
			return (start,None)
 
		# while x is not None: # přesunuto do PropValue.listOf
 
			# res.values.append(x)
 
			# i=skipWhitespace(str,i)
 
			# i,x=PropValue.create(str,i,res.name)
 
			# i=skipWhitespace(s,i)
 
			# i,x=PropValue.create(s,i,res.name)
 
		return (i,res)
 
 
	@staticmethod
 
	def ident(str,start):
 
	def ident(s,start):
 
		r=re.compile(r"[A-Z]+")
 
		m=r.match(str,start)
 
		m=r.match(s,start)
 
		if m is None: return (start,None)
 
		return (m.end(),m.group())
 
 
class PropValue:
 
	def __init__(self):
 
		self.type=""
 
		self.value=None
 
 
	patterns=dict()
 
 
	@staticmethod
 
	def create(str,start,name):
 
	def create(s,start,name):
 
		if name in PropValue.patterns:
 
			return PropValue.patterns[name](str,start)
 
			return PropValue.patterns[name](s,start)
 
		else:
 
			print('warning, unknown property "{0}" at position {1}'.format(name,start))
 
			return PropValue.singleton(PropValue.anything)(str,start)
 
			return PropValue.singleton(PropValue.anything)(s,start)
 
 
	# def singleton(str,start,vType):
 
		# if str[start]!="[":
 
	# def singleton(s,start,vType):
 
		# if s[start]!="[":
 
			# return (start,None)
 
		# i,x=vType(str,start+1)
 
		# i,x=vType(s,start+1)
 
		# if x is None: return (start,None)
 
		# if str[i]!="]":
 
		# if s[i]!="]":
 
			# return (start,None)
 
		# return (i+1,x)
 
 
	def choose(*vTypes):
 
		def f(str,start):
 
		def f(s,start):
 
			for vType in vTypes:
 
				i,x=vType(str,start)
 
				i,x=vType(s,start)
 
				if x is not None: return (i,x)
 
			return (start,None)
 
		return f
 
 
	def singleton(vType):
 
		def f(str,start):
 
			if str[start]!="[":
 
		def f(s,start):
 
			if s[start]!="[":
 
				return (start,None)
 
			i,x=vType(str,start+1)
 
			i,x=vType(s,start+1)
 
			if x is None: return (start,None)
 
			if str[i]!="]":
 
			if s[i]!="]":
 
				return (start,None)
 
			return (i+1,x)
 
		return f
 
 
	# def listOf(str,start,vType,allowEmpty=False):
 
	# def listOf(s,start,vType,allowEmpty=False):
 
		# res=[]
 
		# i,x=singleton(str,start,vType)
 
		# i,x=singleton(s,start,vType)
 
		# # singleton(vType) if vType not tuple else compose(vType[0],vType[1])
 
		# while x!=None:
 
			# res.append(x)
 
			# i,x=singleton(str,i,vType)
 
			# i,x=singleton(s,i,vType)
 
		# if len(res)==0 and not allowEmpty: return (start,None)
 
		# return (i,res)
 
 
	def listOf(vType,allowEmpty=False):
 
		def f(str,start):
 
		def f(s,start):
 
			res=[]
 
			single=PropValue.singleton(vType)
 
			i,x=single(str,start)
 
			i,x=single(s,start)
 
			while x!=None:
 
				res.append(x)
 
				i,x=single(str,i)
 
				i,x=single(s,i)
 
			if len(res)==0 and not allowEmpty: return (start,None)
 
			return (i,res)
 
		return f
 
 
	# def compose(str,start,vTypeA,vTypeB):
 
		# i,a=vTypeA(str,start)
 
		# if a==None or str[i]!=":": return (start,None)
 
		# i,b=vTypeB(str,i+1)
 
	# def compose(s,start,vTypeA,vTypeB):
 
		# i,a=vTypeA(s,start)
 
		# if a==None or s[i]!=":": return (start,None)
 
		# i,b=vTypeB(s,i+1)
 
		# if b==None: return start,None
 
		# return (i,(a,b))
 
 
	def compose(vTypeA,vTypeB):
 
		def f(str,start):
 
			i,a=vTypeA(str,start)
 
		def f(s,start):
 
			i,a=vTypeA(s,start)
 
			# print(">",i,a)
 
			if a==None or str[i]!=":": return (start,None)
 
			i,b=vTypeB(str,i+1)
 
			if a==None or s[i]!=":": return (start,None)
 
			i,b=vTypeB(s,i+1)
 
			# print(">",i,b)
 
			if b==None: return start,None
 
			return (i,(a,b))
 
		return f
 
 
	def number(str,start):
 
	def number(s,start):
 
		r=re.compile(r"(\+|-|)\d+")
 
		m=r.match(str,start)
 
		m=r.match(s,start)
 
		if m is None: return (start,None)
 
		res=int(m.group(0))
 
		return (m.end(),res)
 
 
	def real(str,start):
 
	def real(s,start):
 
		r=re.compile(r"(\+|-|)\d+(\.\d+)?")
 
		m=r.match(str,start)
 
		m=r.match(s,start)
 
		if m is None: return (start,None)
 
		res=float(m.group(0))
 
		return (m.end(),res)
 
 
	def double(str,start):
 
	def double(s,start):
 
		r=re.compile(r"1|2")
 
		m=r.match(str,start)
 
		m=r.match(s,start)
 
		if m is None: return (start,None)
 
		res=int(m.group(0))
 
		return (m.end(),res)
 
 
	def color(str,start):
 
	def color(s,start):
 
		r=re.compile(r"B|W")
 
		m=r.match(str,start)
 
		m=r.match(s,start)
 
		if m is None: return (start,None)
 
		return (m.end(),m.group(0))
 
 
	# def simpleText(str,start):
 
	# def simpleText(s,start):
 
		# res=""
 
		# esc=False
 
		# lineBreak=False
 
		# for c in str:
 
		# for c in s:
 
			# if esc:
 
				# res+=c
 
				# esc=False
 
			# elif c=="\\":
 
				# esc=True
 
			# elif c=="]":
 
				# break
 
			# else:
 
				# res+=c
 
		# return res
 
 
	def text(simple=True,composed=False):
 
		def f(str,start):
 
		def f(s,start):
 
			res=""
 
			esc=False
 
			lastC=""
 
			for i,c in enumerate(str[start:],start):
 
			for i,c in enumerate(s[start:],start):
 
				if esc:
 
					if c!="\n" and c!="\r": res+=c
 
					esc=False
 
				elif (c=="\n" and lastC=="\r") or (c=="\r" and lastC=="\n"): pass
 
				elif c=="\r" or c=="\n" and not simple:
 
					res+="\n"
 
				elif c.isspace():
 
					res+=" "
 
				elif c=="\\":
 
					esc=True
 
				elif c=="]" or (c==":" and composed):
 
					break
 
				else:
 
					res+=c
 
				lastC=c
 
			return (i,res)
 
		return f
 
 
	def empty(str,start): return (start,"")
 
	def empty(s,start): return (start,"")
 
 
	def anything(str,start):
 
	def anything(s,start):
 
		esc=False
 
		for i,c in enumerate(str[start:],start):
 
		for i,c in enumerate(s[start:],start):
 
			if esc: esc=False
 
			elif c=="\\": esc=True
 
			elif c=="]": break
 
		return (i,str[start:i])
 
		return (i,s[start:i])
 
 
	# go specific
 
	def point(str,start):
 
	def point(s,start):
 
		r=re.compile(r"[a-zA-Z]{2}|") # !! limit to board size
 
		m=r.match(str,start)
 
		m=r.match(s,start)
 
		if m is None: return (start,None)
 
		if m.group(0)=="": # pass, !! tt
 
			return (m.end(),tuple())
 
		col=m.group(0)[0]
 
		row=m.group(0)[1]
 
		col=ord(col) - (ord("a") if "a"<=col<="z" else ord("A")-26)
 
		row=ord(row) - (ord("a") if "a"<=row<="z" else ord("A")-26)
 
		return (m.end(),(col,row))
 
 
	move=point
 
	stone=point
 
 
	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),
 
@@ -359,104 +359,104 @@ class PropValue:
 
		"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)
 
	}
 
 
class ParserError(Exception):
 
	def __init__(self,line,col,message):
 
		self.line=line
 
		self.col=col
 
		self.message=message
 
 
 
 
"""def property(str):
 
	# i=propIdent(str)
 
"""def property(s):
 
	# i=propIdent(s)
 
	# if i<0: return -1
 
	# j=i
 
	# i=propValue(str[i:])
 
	# i=propValue(s[i:])
 
	# while i>=0:
 
		# j+=i
 
		# i=propValue(str[i:])
 
		# i=propValue(s[i:])
 
	# return j
 
 
def propIdent(str):
 
	m=re.match(r"[A-Z]+",str)
 
def propIdent(s):
 
	m=re.match(r"[A-Z]+",s)
 
	if m is None: return -1
 
	return m.end()
 
 
def propValue(str):
 
	i=cValueType(str[1:])
 
	if str[0]=="[" and i>=0 and str[i]=="]": return i+1
 
def propValue(s):
 
	i=cValueType(s[1:])
 
	if s[0]=="[" and i>=0 and s[i]=="]": return i+1
 
	else: return -1
 
 
class propValue:
 
	pass
 
 
def cValueType(str,start):
 
def cValueType(s,start):
 
	matches=[real,number,double,color,simpleText]
 
	for f in matches:
 
		i,x=f(str,start)
 
		i,x=f(s,start)
 
		if x is not None: return i,x
 
	return 1/0
 
 
def number(str,start):
 
def number(s,start):
 
	r=re.compile(r"(\+|-|)\d+")
 
	m=r.match(str,start)
 
	m=r.match(s,start)
 
	if m is None: return (-1,None)
 
	x=int(m.group(0))
 
	return (m.end(),x)
 
 
def real(str):
 
	m=re.match(r"(\+|-|)\d+(\.\d+)?",str)
 
def real(s):
 
	m=re.match(r"(\+|-|)\d+(\.\d+)?",s)
 
	if m is None: return -1
 
	return m.end()
 
 
def double(str):
 
	m=re.match(r"1|2",str)
 
def double(s):
 
	m=re.match(r"1|2",s)
 
	if m is None: return -1
 
	return m.end()
 
 
def color(str):
 
	m=re.match(r"B|W",str)
 
def color(s):
 
	m=re.match(r"B|W",s)
 
	if m is None: return -1
 
	return m.end()
 
 
def simpleText(str):
 
def simpleText(s):
 
	res=r""
 
	esc=False
 
	for c in str:
 
	for c in s:
 
		if esc:
 
			res+=c
 
			esc=False
 
		elif c=="\\":
 
			esc=True
 
		elif c=="]":
 
			break
 
		else:
 
			res+=c
 
	return res"""
 
 
# TODO:
 
# date
 
 
 
"""
 
# move
 
B	move
 
KO	none
 
MN	number
 
W	move
 
 
# setup
 
AB	list of stone
src/diana/tests/__init__.py
➞
Show inline comments
 
modified file chmod 100644 => 100755
src/diana/tests/data/kogos.sgf
➞
Show inline comments
 
modified file chmod 100644 => 100755
src/diana/tests/sgfParser.py
➞
Show inline comments
 
modified file chmod 100644 => 100755
0 comments (0 inline, 0 general)
Server instance: Sirius-560 This site is powered by Kallithea 0.7.0, which is © 2010–2023 by various authors & licensed under GPLv3. – Support